diff --git a/target_chains/iota/README.md b/target_chains/iota/README.md new file mode 100644 index 0000000000..975fffa158 --- /dev/null +++ b/target_chains/iota/README.md @@ -0,0 +1,9 @@ +# Pyth on Sui + +This directory contains the Pyth contract for Sui and utilities to deploy and use it. + +- `cli` folder contains tools for deploying and upgrading the Pyth contract. +- `contracts` folder contains the Pyth contract source code in Move. +- `sdk` folder contains the Pyth javascript SDK for Sui that should be used by dApp developers. + +For more information regarding Pyth integration on Sui please refer to our [docs](https://docs.pyth.network/documentation/pythnet-price-feeds/sui). diff --git a/target_chains/iota/cli-iota/.gitignore b/target_chains/iota/cli-iota/.gitignore new file mode 100644 index 0000000000..a65b41774a --- /dev/null +++ b/target_chains/iota/cli-iota/.gitignore @@ -0,0 +1 @@ +lib diff --git a/target_chains/iota/cli-iota/README.md b/target_chains/iota/cli-iota/README.md new file mode 100644 index 0000000000..aede9ba8d4 --- /dev/null +++ b/target_chains/iota/cli-iota/README.md @@ -0,0 +1,69 @@ +# Pre-requisites + +Install move cli according to this [doc](../contracts/README.md) + +# Deploying from scratch + +Configure the `Move.toml` file accordingly. The wormhole address should be specified based on the target chain in the `Move.toml` and the pyth address should be `0x0`. +We can deploy the pyth oracle and initialize it with the following command: + +```bash +npm run cli -- deploy --private-key --chain [iota_sui|iota_sui] +``` + +You can then add your iota contract configs to the contract manager store. + +You can also manually create all the price feeds available at the moment to make it easier for devs to test the oracle. + +```bash +npm run cli -- create-all --private-key --contract +``` + +# Updating price feeds: + +You can use the `create` and `update-feeds` commands to create and update price feeds respectively. + +```bash +npm run cli -- create --feed-id --private-key --contract +``` + +```bash +npm run cli -- update-feeds --feed-id --private-key --contract +``` + +# Upgrade process: + +The following steps are needed to upgrade our iota contracts: + +- Contract changes: + - Create a new struct for the new version and update `current_version` and `previous_version` functions in `version_control` module + - Implement any custom logic needed to migrate the data from the old struct to the new one in the `migrate` module + - Update dependency (e.g. wormhole) addresses if needed +- Generate the digest for the new contract build +- Create a governance proposal, proposing the iota package to be upgraded to this specific digest +- Approve and execute the governance proposal +- Run the upgrade transaction and publish the new package + +## Generating the new contract hash: + +Run the following command to generate the new hash, make sure the contract addresses are identical to the deployed ones: + +```bash +npm run cli -- generate-digest +``` + +## Upgrading the contract + +To upgrade the contract after the governance vaa was executed run: + +```bash +npm run cli -- upgrade --private-key --contract --vaa +``` + +The upgrade procedure consists of 2 transactions. The first one is to upgrade the contract (iota level) and the second one is to run the `migrate` function and upgrade the version (package level). +Since clients try to fetch the latest version of the package automatically, it's important to run the second transaction as soon as possible after the first one. + +### FAQ: + +- I'm seeing the error `Transaction has non recoverable errors from at least 1/3 of validators`. What should I do? + Make sure you have enough funding in the wallet and try again. Usually a more descriptive error message is available in the returned value of the transaction. diff --git a/target_chains/iota/cli-iota/package.json b/target_chains/iota/cli-iota/package.json new file mode 100644 index 0000000000..189d8bc0d4 --- /dev/null +++ b/target_chains/iota/cli-iota/package.json @@ -0,0 +1,27 @@ +{ + "name": "pyth-iota-cli", + "version": "0.1.0", + "description": "Pyth IOTA Integration Cli tools", + "main": "index.js", + "license": "Apache-2.0", + "scripts": { + "cli": "ts-node src/cli.ts", + "build": "tsc" + }, + "private": "true", + "dependencies": { + "@certusone/wormhole-sdk": "^0.9.12", + "@iota/iota-sdk": "^0.5.0", + "@pythnetwork/contract-manager": "workspace:*", + "@pythnetwork/price-service-client": "^1.4.0", + "@pythnetwork/price-service-sdk": "^1.2.0", + "@pythnetwork/xc-admin-common": "workspace:*", + "prettier": "^2.8.7", + "ts-node": "^10.9.1", + "typescript": "^5.0.4", + "yargs": "^17.7.2" + }, + "devDependencies": { + "@types/yargs": "^17.0.32" + } +} diff --git a/target_chains/iota/cli-iota/src/cli.ts b/target_chains/iota/cli-iota/src/cli.ts new file mode 100644 index 0000000000..ea5311556a --- /dev/null +++ b/target_chains/iota/cli-iota/src/cli.ts @@ -0,0 +1,288 @@ +import yargs from "yargs"; +import { hideBin } from "yargs/helpers"; +import { + DefaultStore, + getDefaultDeploymentConfig, + IotaChain, + IotaPriceFeedContract, +} from "@pythnetwork/contract-manager"; +import { PriceServiceConnection } from "@pythnetwork/price-service-client"; +import { execSync } from "child_process"; +import { initPyth, publishPackage } from "./pyth_deploy"; +import { Ed25519Keypair } from "@iota/iota-sdk/keypairs/ed25519"; +import { resolve } from "path"; +import { + buildForBytecodeAndDigest, + migratePyth, + upgradePyth, +} from "./upgrade_pyth"; + +const OPTIONS = { + "private-key": { + type: "string", + demandOption: true, + desc: "Private key to use to sign transaction", + }, + contract: { + type: "string", + demandOption: true, + desc: "Contract to use for the command (e.g iota_0x68dda579251917b3db28e35c4df495c6e664ccc085ede867a9b773c8ebedc2c1)", + }, + path: { + type: "string", + default: "../../contracts", + desc: "Path to the iota contracts, will use ../../contracts by default", + }, + endpoint: { + type: "string", + default: "https://hermes.pyth.network", + desc: "Price service endpoint to use, defaults to https://hermes.pyth.network", + }, + "feed-id": { + type: "array", + demandOption: true, + desc: "Price feed ids to create without the leading 0x (e.g f9c0172ba10dfa4d19088d94f5bf61d3b54d5bd7483a322a982e1373ee8ea31b). Can be provided multiple times for multiple feed updates", + }, +} as const; + +function getContract(contractId: string): IotaPriceFeedContract { + const contract = DefaultStore.contracts[contractId] as IotaPriceFeedContract; + if (!contract) { + throw new Error(`Contract ${contractId} not found`); + } + return contract; +} + +yargs(hideBin(process.argv)) + .command( + "create", + "Create a new price feed", + (yargs) => { + return yargs + .options({ + contract: OPTIONS.contract, + "feed-id": OPTIONS["feed-id"], + "private-key": OPTIONS["private-key"], + endpoint: OPTIONS.endpoint, + }) + .usage( + "$0 create --contract --feed-id --private-key " + ); + }, + async (argv) => { + const contract = getContract(argv.contract); + const priceService = new PriceServiceConnection(argv.endpoint); + const feedIds = argv["feed-id"] as string[]; + const vaas = await priceService.getLatestVaas(feedIds); + const digest = await contract.executeCreatePriceFeed( + argv["private-key"], + vaas.map((vaa) => Buffer.from(vaa, "base64")) + ); + console.log("Transaction successful. Digest:", digest); + } + ) + .command( + "create-all", + "Create all price feeds for a contract", + (yargs) => { + return yargs + .options({ + contract: OPTIONS.contract, + "private-key": OPTIONS["private-key"], + endpoint: OPTIONS.endpoint, + }) + .usage( + "$0 create-all --contract --private-key " + ); + }, + async (argv) => { + const contract = getContract(argv.contract); + const priceService = new PriceServiceConnection(argv.endpoint); + const feedIds = await priceService.getPriceFeedIds(); + const BATCH_SIZE = 10; + for (let i = 0; i < feedIds.length; i += BATCH_SIZE) { + const batch = feedIds.slice(i, i + BATCH_SIZE); + const vaas = await priceService.getLatestVaas(batch); + const digest = await contract.executeCreatePriceFeed( + argv["private-key"], + vaas.map((vaa) => Buffer.from(vaa, "base64")) + ); + console.log("Transaction successful. Digest:", digest); + console.log(`Progress: ${i + BATCH_SIZE}/${feedIds.length}`); + } + } + ) + .command( + "generate-digest", + "Generate digest for a contract", + (yargs) => { + return yargs + .options({ + path: OPTIONS.path, + }) + .usage("$0 generate-digest --path "); + }, + async (argv) => { + const buildOutput: { + modules: string[]; + dependencies: string[]; + digest: number[]; + } = JSON.parse( + execSync( + `iota move build --dump-bytecode-as-base64 --path ${__dirname}/${argv.path} 2> /dev/null`, + { + encoding: "utf-8", + } + ) + ); + console.log("Contract digest:"); + console.log(Buffer.from(buildOutput.digest).toString("hex")); + } + ) + .command( + "deploy", + "Deploy a contract", + (yargs) => { + return yargs + .options({ + "private-key": OPTIONS["private-key"], + chain: { + type: "string", + demandOption: true, + desc: "Chain to deploy the code to. Can be iota_mainnet or iota_testnet", + }, + path: OPTIONS.path, + }) + .usage( + "$0 deploy --private-key --chain [iota_mainnet|iota_testnet] --path " + ); + }, + async (argv) => { + const walletPrivateKey = argv["private-key"]; + const chain = DefaultStore.chains[argv.chain] as IotaChain; + const keypair = Ed25519Keypair.fromSecretKey( + new Uint8Array(Buffer.from(walletPrivateKey, "hex")) + ); + const result = await publishPackage( + keypair, + chain.getProvider(), + argv.path + ); + const deploymentType = "stable"; + const config = getDefaultDeploymentConfig(deploymentType); + await initPyth( + keypair, + chain.getProvider(), + result.packageId, + result.deployerCapId, + result.upgradeCapId, + config + ); + } + ) + .command( + "update-feeds", + "Update price feeds for a contract", + (yargs) => { + return yargs + .options({ + contract: OPTIONS.contract, + "feed-id": OPTIONS["feed-id"], + "private-key": OPTIONS["private-key"], + endpoint: OPTIONS.endpoint, + }) + .usage( + "$0 update-feeds --contract --feed-id --private-key " + ); + }, + async (argv) => { + const contract = getContract(argv.contract); + const priceService = new PriceServiceConnection(argv.endpoint); + const feedIds = argv["feed-id"] as string[]; + const vaas = await priceService.getLatestVaas(feedIds); + const digest = await contract.executeUpdatePriceFeedWithFeeds( + argv["private-key"], + vaas.map((vaa) => Buffer.from(vaa, "base64")), + feedIds + ); + console.log("Transaction successful. Digest:", digest); + } + ) + .command( + "upgrade", + "Upgrade a contract", + (yargs) => { + return yargs + .options({ + "private-key": OPTIONS["private-key"], + contract: OPTIONS.contract, + vaa: { + type: "string", + demandOption: true, + desc: "Signed Vaa for upgrading the package in hex format", + }, + path: OPTIONS.path, + }) + .usage( + "$0 upgrade --private-key --contract --vaa " + ); + }, + async (argv) => { + const contract = getContract(argv.contract); + const keypair = Ed25519Keypair.fromSecretKey( + new Uint8Array(Buffer.from(argv["private-key"], "hex")) + ); + + const pythContractsPath = resolve(`${__dirname}/${argv.path}`); + + // Build for modules and dependencies + const { modules, dependencies, digest } = + buildForBytecodeAndDigest(pythContractsPath); + //Execute upgrade with signed governance VAA. + console.log("Digest is", digest.toString("hex")); + const pythPackageOld = await contract.getPackageId(contract.stateId); + console.log("Old package id:", pythPackageOld); + const signedVaa = Buffer.from(argv.vaa, "hex"); + const upgradeResults = await upgradePyth( + keypair, + contract.chain.getProvider(), + modules, + dependencies, + signedVaa, + contract + ); + console.log("Tx digest", upgradeResults.digest); + if ( + !upgradeResults.effects || + upgradeResults.effects.status.status !== "success" + ) { + throw new Error("Upgrade failed"); + } + + console.log( + "Upgrade successful, Executing the migrate function in a separate transaction..." + ); + + // We can not do the migration in the same transaction since the newly published package is not found + // on chain at the beginning of the transaction. + + const migrateResults = await migratePyth( + keypair, + contract.chain.getProvider(), + signedVaa, + contract, + pythPackageOld + ); + console.log("Tx digest", migrateResults.digest); + if ( + !migrateResults.effects || + migrateResults.effects.status.status !== "success" + ) { + throw new Error( + `Migrate failed. Old package id is ${pythPackageOld}. Please do the migration manually` + ); + } + console.log("Migrate successful"); + } + ) + .demandCommand().argv; diff --git a/target_chains/iota/cli-iota/src/pyth_deploy.ts b/target_chains/iota/cli-iota/src/pyth_deploy.ts new file mode 100644 index 0000000000..2b28dc0c63 --- /dev/null +++ b/target_chains/iota/cli-iota/src/pyth_deploy.ts @@ -0,0 +1,185 @@ +import { Transaction } from "@iota/iota-sdk/transactions"; + +import { + NANOS_PER_IOTA, + normalizeIotaObjectId, + fromB64, +} from "@iota/iota-sdk/utils"; + +import { Ed25519Keypair } from "@iota/iota-sdk/keypairs/ed25519"; +import { execSync } from "child_process"; +import { DataSource } from "@pythnetwork/xc-admin-common"; +import { IotaClient } from "@iota/iota-sdk/client"; +import { bcs } from "@iota/iota-sdk/bcs"; + +export async function publishPackage( + keypair: Ed25519Keypair, + provider: IotaClient, + packagePath: string +): Promise<{ packageId: string; upgradeCapId: string; deployerCapId: string }> { + // Build contracts + const buildOutput: { + modules: string[]; + dependencies: string[]; + } = JSON.parse( + execSync( + `iota move build --dump-bytecode-as-base64 --path ${__dirname}/${packagePath} 2> /dev/null`, + { + encoding: "utf-8", + } + ) + ); + + console.log("buildOutput: ", buildOutput); + + // Publish contracts + const txb = new Transaction(); + + txb.setGasBudget(NANOS_PER_IOTA / 2n); // 0.5 IOTA + + const [upgradeCap] = txb.publish({ + modules: buildOutput.modules.map((m: string) => Array.from(fromB64(m))), + dependencies: buildOutput.dependencies.map((d: string) => + normalizeIotaObjectId(d) + ), + }); + + // Transfer upgrade capability to deployer + txb.transferObjects([upgradeCap], txb.pure.address(keypair.toIotaAddress())); + + // Execute transactions + const result = await provider.signAndExecuteTransaction({ + signer: keypair, + transaction: txb, + options: { + showInput: true, + showObjectChanges: true, + }, + }); + + const publishedChanges = result.objectChanges?.filter( + (change) => change.type === "published" + ); + + if ( + publishedChanges?.length !== 1 || + publishedChanges[0].type !== "published" + ) { + throw new Error( + "No publish event found in transaction:" + + JSON.stringify(result.objectChanges, null, 2) + ); + } + + const packageId = publishedChanges[0].packageId; + + console.log("Published with package id: ", packageId); + console.log("Tx digest", result.digest); + let upgradeCapId: string | undefined; + let deployerCapId: string | undefined; + for (const objectChange of result.objectChanges!) { + if (objectChange.type === "created") { + if (objectChange.objectType === "0x2::package::UpgradeCap") { + upgradeCapId = objectChange.objectId; + } + if (objectChange.objectType === `${packageId}::setup::DeployerCap`) { + deployerCapId = objectChange.objectId; + } + } + } + if (!upgradeCapId || !deployerCapId) { + throw new Error("Could not find upgrade cap or deployer cap"); + } + console.log("UpgradeCapId: ", upgradeCapId); + console.log("DeployerCapId: ", deployerCapId); + return { + packageId, + upgradeCapId: upgradeCapId, + deployerCapId: deployerCapId, + }; +} + +export async function initPyth( + keypair: Ed25519Keypair, + provider: IotaClient, + pythPackageId: string, + deployerCapId: string, + upgradeCapId: string, + config: { + dataSources: DataSource[]; + governanceDataSource: DataSource; + } +) { + const tx = new Transaction(); + + const baseUpdateFee = tx.pure.u64(1); + const dataSourceEmitterAddresses = tx.pure( + bcs + .vector(bcs.vector(bcs.u8())) + .serialize( + config.dataSources.map((dataSource) => [ + ...Buffer.from(dataSource.emitterAddress, "hex"), + ]) + ) + ); + const dataSourceEmitterChainIds = tx.pure( + bcs + .vector(bcs.u64()) + .serialize( + config.dataSources.map((dataSource) => dataSource.emitterChain) + ) + ); + const governanceEmitterAddress = tx.pure( + bcs + .vector(bcs.u8()) + .serialize([ + ...Buffer.from(config.governanceDataSource.emitterAddress, "hex"), + ]) + ); + const governanceEmitterChainId = tx.pure( + bcs.u64().serialize(config.governanceDataSource.emitterChain) + ); + const stalePriceThreshold = tx.pure.u64(60); + tx.moveCall({ + target: `${pythPackageId}::pyth::init_pyth`, + arguments: [ + tx.object(deployerCapId), + tx.object(upgradeCapId), + stalePriceThreshold, + governanceEmitterChainId, + governanceEmitterAddress, + dataSourceEmitterChainIds, + dataSourceEmitterAddresses, + baseUpdateFee, + ], + }); + + tx.setGasBudget(NANOS_PER_IOTA / 10n); // 0.1 IOTA + + let result = await provider.signAndExecuteTransaction({ + signer: keypair, + transaction: tx, + options: { + showInput: true, + showEffects: true, + showEvents: true, + showObjectChanges: true, + showBalanceChanges: true, + }, + }); + if (!result.effects || !result.objectChanges) { + throw new Error("No effects or object changes found in transaction"); + } + if (result.effects.status.status === "success") { + console.log("Pyth init successful"); + console.log("Tx digest", result.digest); + } + for (const objectChange of result.objectChanges) { + if (objectChange.type === "created") { + if (objectChange.objectType === `${pythPackageId}::state::State`) { + console.log("Pyth state id: ", objectChange.objectId); + } + } + } + return result; +} diff --git a/target_chains/iota/cli-iota/src/upgrade_pyth.ts b/target_chains/iota/cli-iota/src/upgrade_pyth.ts new file mode 100644 index 0000000000..260733956b --- /dev/null +++ b/target_chains/iota/cli-iota/src/upgrade_pyth.ts @@ -0,0 +1,115 @@ +import { Transaction } from "@iota/iota-sdk/transactions"; +import { + fromB64, + NANOS_PER_IOTA, + normalizeIotaObjectId, +} from "@iota/iota-sdk/utils"; +import { IotaClient } from "@iota/iota-sdk/client"; +import { Ed25519Keypair } from "@iota/iota-sdk/keypairs/ed25519"; + +import { execSync } from "child_process"; +import { IotaPriceFeedContract } from "@pythnetwork/contract-manager"; + +export function buildForBytecodeAndDigest(packagePath: string) { + const buildOutput: { + modules: string[]; + dependencies: string[]; + digest: number[]; + } = JSON.parse( + execSync( + `iota move build --dump-bytecode-as-base64 -p ${packagePath} 2> /dev/null`, + { encoding: "utf-8" } + ) + ); + return { + modules: buildOutput.modules.map((m: string) => Array.from(fromB64(m))), + dependencies: buildOutput.dependencies.map((d: string) => + normalizeIotaObjectId(d) + ), + digest: Buffer.from(buildOutput.digest), + }; +} + +export async function upgradePyth( + keypair: Ed25519Keypair, + provider: IotaClient, + modules: number[][], + dependencies: string[], + signedVaa: Buffer, + contract: IotaPriceFeedContract +) { + const pythPackage = await contract.getPackageId(contract.stateId); + + const tx = new Transaction(); + + const verificationReceipt = await contract.getVaaVerificationReceipt( + tx as any, + pythPackage, + signedVaa + ); + + // Authorize upgrade. + const [upgradeTicket] = tx.moveCall({ + target: `${pythPackage}::contract_upgrade::authorize_upgrade`, + arguments: [tx.object(contract.stateId), verificationReceipt as any], + }); + + // Build and generate modules and dependencies for upgrade. + const [upgradeReceipt] = tx.upgrade({ + modules, + dependencies, + package: pythPackage, + ticket: upgradeTicket, + }); + + // Commit upgrade. + tx.moveCall({ + target: `${pythPackage}::contract_upgrade::commit_upgrade`, + arguments: [tx.object(contract.stateId), upgradeReceipt], + }); + + tx.setGasBudget(NANOS_PER_IOTA / 4n); // 0.25 IOTA + + return provider.signAndExecuteTransaction({ + signer: keypair, + transaction: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} + +export async function migratePyth( + keypair: Ed25519Keypair, + provider: IotaClient, + signedUpgradeVaa: Buffer, + contract: IotaPriceFeedContract, + pythPackageOld: string +) { + const pythPackage = await contract.getPackageId(contract.stateId); + const tx = new Transaction(); + // The pyth package version is not updated yet, therefore we can not get the verification receipts from the new + // package yet. We need to use the old package id to get the verification receipt in this transaction and then submit + // it to the migrate function in the new package! + const verificationReceipt = await contract.getVaaVerificationReceipt( + tx, + pythPackageOld, + signedUpgradeVaa + ); + tx.moveCall({ + target: `${pythPackage}::migrate::migrate`, + arguments: [tx.object(contract.stateId), verificationReceipt as any], + }); + + tx.setGasBudget(NANOS_PER_IOTA / 10n); //0.1 IOTA + + return provider.signAndExecuteTransaction({ + signer: keypair, + transaction: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} diff --git a/target_chains/iota/cli-iota/tsconfig.json b/target_chains/iota/cli-iota/tsconfig.json new file mode 100644 index 0000000000..be27cdded2 --- /dev/null +++ b/target_chains/iota/cli-iota/tsconfig.json @@ -0,0 +1,9 @@ +{ + "extends": "../../../tsconfig.base.json", + "include": ["src"], + "exclude": ["node_modules", "**/__tests__/*"], + "compilerOptions": { + "rootDir": "src/", + "outDir": "./lib" + } +} diff --git a/target_chains/iota/cli/.gitignore b/target_chains/iota/cli/.gitignore new file mode 100644 index 0000000000..a65b41774a --- /dev/null +++ b/target_chains/iota/cli/.gitignore @@ -0,0 +1 @@ +lib diff --git a/target_chains/iota/cli/README.md b/target_chains/iota/cli/README.md new file mode 100644 index 0000000000..cf4a0275a6 --- /dev/null +++ b/target_chains/iota/cli/README.md @@ -0,0 +1,69 @@ +# Pre-requisites + +Install move cli according to this [doc](../contracts/README.md) + +# Deploying from scratch + +Configure the `Move.toml` file accordingly. The wormhole address should be specified based on the target chain in the `Move.toml` and the pyth address should be `0x0`. +We can deploy the pyth oracle and initialize it with the following command: + +```bash +npm run cli -- deploy --private-key --chain [sui_mainnet|sui_testnet] +``` + +You can then add your sui contract configs to the contract manager store. + +You can also manually create all the price feeds available at the moment to make it easier for devs to test the oracle. + +```bash +npm run cli -- create-all --private-key --contract +``` + +# Updating price feeds: + +You can use the `create` and `update-feeds` commands to create and update price feeds respectively. + +```bash +npm run cli -- create --feed-id --private-key --contract +``` + +```bash +npm run cli -- update-feeds --feed-id --private-key --contract +``` + +# Upgrade process: + +The following steps are needed to upgrade our sui contracts: + +- Contract changes: + - Create a new struct for the new version and update `current_version` and `previous_version` functions in `version_control` module + - Implement any custom logic needed to migrate the data from the old struct to the new one in the `migrate` module + - Update dependency (e.g. wormhole) addresses if needed +- Generate the digest for the new contract build +- Create a governance proposal, proposing the sui package to be upgraded to this specific digest +- Approve and execute the governance proposal +- Run the upgrade transaction and publish the new package + +## Generating the new contract hash: + +Run the following command to generate the new hash, make sure the contract addresses are identical to the deployed ones: + +```bash +npm run cli -- generate-digest +``` + +## Upgrading the contract + +To upgrade the contract after the governance vaa was executed run: + +```bash +npm run cli -- upgrade --private-key --contract --vaa +``` + +The upgrade procedure consists of 2 transactions. The first one is to upgrade the contract (sui level) and the second one is to run the `migrate` function and upgrade the version (package level). +Since clients try to fetch the latest version of the package automatically, it's important to run the second transaction as soon as possible after the first one. + +### FAQ: + +- I'm seeing the error `Transaction has non recoverable errors from at least 1/3 of validators`. What should I do? + Make sure you have enough funding in the wallet and try again. Usually a more descriptive error message is available in the returned value of the transaction. diff --git a/target_chains/iota/cli/package.json b/target_chains/iota/cli/package.json new file mode 100644 index 0000000000..8aebfa4f33 --- /dev/null +++ b/target_chains/iota/cli/package.json @@ -0,0 +1,27 @@ +{ + "name": "pyth-sui-cli", + "version": "0.1.0", + "description": "Pyth Sui Integration Cli tools", + "main": "index.js", + "license": "Apache-2.0", + "scripts": { + "cli": "ts-node src/cli.ts", + "build": "tsc" + }, + "private": "true", + "dependencies": { + "@certusone/wormhole-sdk": "^0.9.12", + "@mysten/sui": "^1.3.0", + "@pythnetwork/contract-manager": "workspace:*", + "@pythnetwork/price-service-client": "^1.4.0", + "@pythnetwork/price-service-sdk": "^1.2.0", + "@pythnetwork/xc-admin-common": "workspace:*", + "prettier": "^2.8.7", + "ts-node": "^10.9.1", + "typescript": "^5.0.4", + "yargs": "^17.7.2" + }, + "devDependencies": { + "@types/yargs": "^17.0.32" + } +} diff --git a/target_chains/iota/cli/src/cli.ts b/target_chains/iota/cli/src/cli.ts new file mode 100644 index 0000000000..0d35ebf7b8 --- /dev/null +++ b/target_chains/iota/cli/src/cli.ts @@ -0,0 +1,288 @@ +import yargs from "yargs"; +import { hideBin } from "yargs/helpers"; +import { + DefaultStore, + getDefaultDeploymentConfig, + SuiChain, + SuiPriceFeedContract, +} from "@pythnetwork/contract-manager"; +import { PriceServiceConnection } from "@pythnetwork/price-service-client"; +import { execSync } from "child_process"; +import { initPyth, publishPackage } from "./pyth_deploy"; +import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"; +import { resolve } from "path"; +import { + buildForBytecodeAndDigest, + migratePyth, + upgradePyth, +} from "./upgrade_pyth"; + +const OPTIONS = { + "private-key": { + type: "string", + demandOption: true, + desc: "Private key to use to sign transaction", + }, + contract: { + type: "string", + demandOption: true, + desc: "Contract to use for the command (e.g sui_testnet_0xe8c2ddcd5b10e8ed98e53b12fcf8f0f6fd9315f810ae61fa4001858851f21c88)", + }, + path: { + type: "string", + default: "../../contracts", + desc: "Path to the sui contracts, will use ../../contracts by default", + }, + endpoint: { + type: "string", + default: "https://hermes.pyth.network", + desc: "Price service endpoint to use, defaults to https://hermes.pyth.network", + }, + "feed-id": { + type: "array", + demandOption: true, + desc: "Price feed ids to create without the leading 0x (e.g f9c0172ba10dfa4d19088d94f5bf61d3b54d5bd7483a322a982e1373ee8ea31b). Can be provided multiple times for multiple feed updates", + }, +} as const; + +function getContract(contractId: string): SuiPriceFeedContract { + const contract = DefaultStore.contracts[contractId] as SuiPriceFeedContract; + if (!contract) { + throw new Error(`Contract ${contractId} not found`); + } + return contract; +} + +yargs(hideBin(process.argv)) + .command( + "create", + "Create a new price feed", + (yargs) => { + return yargs + .options({ + contract: OPTIONS.contract, + "feed-id": OPTIONS["feed-id"], + "private-key": OPTIONS["private-key"], + endpoint: OPTIONS.endpoint, + }) + .usage( + "$0 create --contract --feed-id --private-key " + ); + }, + async (argv) => { + const contract = getContract(argv.contract); + const priceService = new PriceServiceConnection(argv.endpoint); + const feedIds = argv["feed-id"] as string[]; + const vaas = await priceService.getLatestVaas(feedIds); + const digest = await contract.executeCreatePriceFeed( + argv["private-key"], + vaas.map((vaa) => Buffer.from(vaa, "base64")) + ); + console.log("Transaction successful. Digest:", digest); + } + ) + .command( + "create-all", + "Create all price feeds for a contract", + (yargs) => { + return yargs + .options({ + contract: OPTIONS.contract, + "private-key": OPTIONS["private-key"], + endpoint: OPTIONS.endpoint, + }) + .usage( + "$0 create-all --contract --private-key " + ); + }, + async (argv) => { + const contract = getContract(argv.contract); + const priceService = new PriceServiceConnection(argv.endpoint); + const feedIds = await priceService.getPriceFeedIds(); + const BATCH_SIZE = 10; + for (let i = 0; i < feedIds.length; i += BATCH_SIZE) { + const batch = feedIds.slice(i, i + BATCH_SIZE); + const vaas = await priceService.getLatestVaas(batch); + const digest = await contract.executeCreatePriceFeed( + argv["private-key"], + vaas.map((vaa) => Buffer.from(vaa, "base64")) + ); + console.log("Transaction successful. Digest:", digest); + console.log(`Progress: ${i + BATCH_SIZE}/${feedIds.length}`); + } + } + ) + .command( + "generate-digest", + "Generate digest for a contract", + (yargs) => { + return yargs + .options({ + path: OPTIONS.path, + }) + .usage("$0 generate-digest --path "); + }, + async (argv) => { + const buildOutput: { + modules: string[]; + dependencies: string[]; + digest: number[]; + } = JSON.parse( + execSync( + `sui move build --dump-bytecode-as-base64 --path ${__dirname}/${argv.path} 2> /dev/null`, + { + encoding: "utf-8", + } + ) + ); + console.log("Contract digest:"); + console.log(Buffer.from(buildOutput.digest).toString("hex")); + } + ) + .command( + "deploy", + "Deploy a contract", + (yargs) => { + return yargs + .options({ + "private-key": OPTIONS["private-key"], + chain: { + type: "string", + demandOption: true, + desc: "Chain to deploy the code to. Can be sui_mainnet or sui_testnet", + }, + path: OPTIONS.path, + }) + .usage( + "$0 deploy --private-key --chain [sui_mainnet|sui_testnet] --path " + ); + }, + async (argv) => { + const walletPrivateKey = argv["private-key"]; + const chain = DefaultStore.chains[argv.chain] as SuiChain; + const keypair = Ed25519Keypair.fromSecretKey( + new Uint8Array(Buffer.from(walletPrivateKey, "hex")) + ); + const result = await publishPackage( + keypair, + chain.getProvider(), + argv.path + ); + const deploymentType = chain.isMainnet() ? "stable" : "beta"; + const config = getDefaultDeploymentConfig(deploymentType); + await initPyth( + keypair, + chain.getProvider(), + result.packageId, + result.deployerCapId, + result.upgradeCapId, + config + ); + } + ) + .command( + "update-feeds", + "Update price feeds for a contract", + (yargs) => { + return yargs + .options({ + contract: OPTIONS.contract, + "feed-id": OPTIONS["feed-id"], + "private-key": OPTIONS["private-key"], + endpoint: OPTIONS.endpoint, + }) + .usage( + "$0 update-feeds --contract --feed-id --private-key " + ); + }, + async (argv) => { + const contract = getContract(argv.contract); + const priceService = new PriceServiceConnection(argv.endpoint); + const feedIds = argv["feed-id"] as string[]; + const vaas = await priceService.getLatestVaas(feedIds); + const digest = await contract.executeUpdatePriceFeedWithFeeds( + argv["private-key"], + vaas.map((vaa) => Buffer.from(vaa, "base64")), + feedIds + ); + console.log("Transaction successful. Digest:", digest); + } + ) + .command( + "upgrade", + "Upgrade a contract", + (yargs) => { + return yargs + .options({ + "private-key": OPTIONS["private-key"], + contract: OPTIONS.contract, + vaa: { + type: "string", + demandOption: true, + desc: "Signed Vaa for upgrading the package in hex format", + }, + path: OPTIONS.path, + }) + .usage( + "$0 upgrade --private-key --contract --vaa " + ); + }, + async (argv) => { + const contract = getContract(argv.contract); + const keypair = Ed25519Keypair.fromSecretKey( + new Uint8Array(Buffer.from(argv["private-key"], "hex")) + ); + + const pythContractsPath = resolve(`${__dirname}/${argv.path}`); + + // Build for modules and dependencies + const { modules, dependencies, digest } = + buildForBytecodeAndDigest(pythContractsPath); + //Execute upgrade with signed governance VAA. + console.log("Digest is", digest.toString("hex")); + const pythPackageOld = await contract.getPackageId(contract.stateId); + console.log("Old package id:", pythPackageOld); + const signedVaa = Buffer.from(argv.vaa, "hex"); + const upgradeResults = await upgradePyth( + keypair, + contract.chain.getProvider(), + modules, + dependencies, + signedVaa, + contract + ); + console.log("Tx digest", upgradeResults.digest); + if ( + !upgradeResults.effects || + upgradeResults.effects.status.status !== "success" + ) { + throw new Error("Upgrade failed"); + } + + console.log( + "Upgrade successful, Executing the migrate function in a separate transaction..." + ); + + // We can not do the migration in the same transaction since the newly published package is not found + // on chain at the beginning of the transaction. + + const migrateResults = await migratePyth( + keypair, + contract.chain.getProvider(), + signedVaa, + contract, + pythPackageOld + ); + console.log("Tx digest", migrateResults.digest); + if ( + !migrateResults.effects || + migrateResults.effects.status.status !== "success" + ) { + throw new Error( + `Migrate failed. Old package id is ${pythPackageOld}. Please do the migration manually` + ); + } + console.log("Migrate successful"); + } + ) + .demandCommand().argv; diff --git a/target_chains/iota/cli/src/pyth_deploy.ts b/target_chains/iota/cli/src/pyth_deploy.ts new file mode 100644 index 0000000000..80d585482c --- /dev/null +++ b/target_chains/iota/cli/src/pyth_deploy.ts @@ -0,0 +1,181 @@ +import { Transaction } from "@mysten/sui/transactions"; + +import { MIST_PER_SUI, normalizeSuiObjectId, fromB64 } from "@mysten/sui/utils"; + +import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"; +import { execSync } from "child_process"; +import { DataSource } from "@pythnetwork/xc-admin-common"; +import { SuiClient } from "@mysten/sui/client"; +import { bcs } from "@mysten/sui/bcs"; + +export async function publishPackage( + keypair: Ed25519Keypair, + provider: SuiClient, + packagePath: string +): Promise<{ packageId: string; upgradeCapId: string; deployerCapId: string }> { + // Build contracts + const buildOutput: { + modules: string[]; + dependencies: string[]; + } = JSON.parse( + execSync( + `sui move build --dump-bytecode-as-base64 --path ${__dirname}/${packagePath} 2> /dev/null`, + { + encoding: "utf-8", + } + ) + ); + + console.log("buildOutput: ", buildOutput); + + // Publish contracts + const txb = new Transaction(); + + txb.setGasBudget(MIST_PER_SUI / 2n); // 0.5 SUI + + const [upgradeCap] = txb.publish({ + modules: buildOutput.modules.map((m: string) => Array.from(fromB64(m))), + dependencies: buildOutput.dependencies.map((d: string) => + normalizeSuiObjectId(d) + ), + }); + + // Transfer upgrade capability to deployer + txb.transferObjects([upgradeCap], txb.pure.address(keypair.toSuiAddress())); + + // Execute transactions + const result = await provider.signAndExecuteTransaction({ + signer: keypair, + transaction: txb, + options: { + showInput: true, + showObjectChanges: true, + }, + }); + + const publishedChanges = result.objectChanges?.filter( + (change) => change.type === "published" + ); + + if ( + publishedChanges?.length !== 1 || + publishedChanges[0].type !== "published" + ) { + throw new Error( + "No publish event found in transaction:" + + JSON.stringify(result.objectChanges, null, 2) + ); + } + + const packageId = publishedChanges[0].packageId; + + console.log("Published with package id: ", packageId); + console.log("Tx digest", result.digest); + let upgradeCapId: string | undefined; + let deployerCapId: string | undefined; + for (const objectChange of result.objectChanges!) { + if (objectChange.type === "created") { + if (objectChange.objectType === "0x2::package::UpgradeCap") { + upgradeCapId = objectChange.objectId; + } + if (objectChange.objectType === `${packageId}::setup::DeployerCap`) { + deployerCapId = objectChange.objectId; + } + } + } + if (!upgradeCapId || !deployerCapId) { + throw new Error("Could not find upgrade cap or deployer cap"); + } + console.log("UpgradeCapId: ", upgradeCapId); + console.log("DeployerCapId: ", deployerCapId); + return { + packageId, + upgradeCapId: upgradeCapId, + deployerCapId: deployerCapId, + }; +} + +export async function initPyth( + keypair: Ed25519Keypair, + provider: SuiClient, + pythPackageId: string, + deployerCapId: string, + upgradeCapId: string, + config: { + dataSources: DataSource[]; + governanceDataSource: DataSource; + } +) { + const tx = new Transaction(); + + const baseUpdateFee = tx.pure.u64(1); + const dataSourceEmitterAddresses = tx.pure( + bcs + .vector(bcs.vector(bcs.u8())) + .serialize( + config.dataSources.map((dataSource) => [ + ...Buffer.from(dataSource.emitterAddress, "hex"), + ]) + ) + ); + const dataSourceEmitterChainIds = tx.pure( + bcs + .vector(bcs.u64()) + .serialize( + config.dataSources.map((dataSource) => dataSource.emitterChain) + ) + ); + const governanceEmitterAddress = tx.pure( + bcs + .vector(bcs.u8()) + .serialize([ + ...Buffer.from(config.governanceDataSource.emitterAddress, "hex"), + ]) + ); + const governanceEmitterChainId = tx.pure( + bcs.u64().serialize(config.governanceDataSource.emitterChain) + ); + const stalePriceThreshold = tx.pure.u64(60); + tx.moveCall({ + target: `${pythPackageId}::pyth::init_pyth`, + arguments: [ + tx.object(deployerCapId), + tx.object(upgradeCapId), + stalePriceThreshold, + governanceEmitterChainId, + governanceEmitterAddress, + dataSourceEmitterChainIds, + dataSourceEmitterAddresses, + baseUpdateFee, + ], + }); + + tx.setGasBudget(MIST_PER_SUI / 10n); // 0.1 sui + + let result = await provider.signAndExecuteTransaction({ + signer: keypair, + transaction: tx, + options: { + showInput: true, + showEffects: true, + showEvents: true, + showObjectChanges: true, + showBalanceChanges: true, + }, + }); + if (!result.effects || !result.objectChanges) { + throw new Error("No effects or object changes found in transaction"); + } + if (result.effects.status.status === "success") { + console.log("Pyth init successful"); + console.log("Tx digest", result.digest); + } + for (const objectChange of result.objectChanges) { + if (objectChange.type === "created") { + if (objectChange.objectType === `${pythPackageId}::state::State`) { + console.log("Pyth state id: ", objectChange.objectId); + } + } + } + return result; +} diff --git a/target_chains/iota/cli/src/upgrade_pyth.ts b/target_chains/iota/cli/src/upgrade_pyth.ts new file mode 100644 index 0000000000..ee2b83cf92 --- /dev/null +++ b/target_chains/iota/cli/src/upgrade_pyth.ts @@ -0,0 +1,111 @@ +import { Transaction } from "@mysten/sui/transactions"; +import { fromB64, MIST_PER_SUI, normalizeSuiObjectId } from "@mysten/sui/utils"; +import { SuiClient } from "@mysten/sui/client"; +import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"; + +import { execSync } from "child_process"; +import { SuiPriceFeedContract } from "@pythnetwork/contract-manager"; + +export function buildForBytecodeAndDigest(packagePath: string) { + const buildOutput: { + modules: string[]; + dependencies: string[]; + digest: number[]; + } = JSON.parse( + execSync( + `sui move build --dump-bytecode-as-base64 -p ${packagePath} 2> /dev/null`, + { encoding: "utf-8" } + ) + ); + return { + modules: buildOutput.modules.map((m: string) => Array.from(fromB64(m))), + dependencies: buildOutput.dependencies.map((d: string) => + normalizeSuiObjectId(d) + ), + digest: Buffer.from(buildOutput.digest), + }; +} + +export async function upgradePyth( + keypair: Ed25519Keypair, + provider: SuiClient, + modules: number[][], + dependencies: string[], + signedVaa: Buffer, + contract: SuiPriceFeedContract +) { + const pythPackage = await contract.getPackageId(contract.stateId); + + const tx = new Transaction(); + + const verificationReceipt = await contract.getVaaVerificationReceipt( + tx as any, + pythPackage, + signedVaa + ); + + // Authorize upgrade. + const [upgradeTicket] = tx.moveCall({ + target: `${pythPackage}::contract_upgrade::authorize_upgrade`, + arguments: [tx.object(contract.stateId), verificationReceipt as any], + }); + + // Build and generate modules and dependencies for upgrade. + const [upgradeReceipt] = tx.upgrade({ + modules, + dependencies, + package: pythPackage, + ticket: upgradeTicket, + }); + + // Commit upgrade. + tx.moveCall({ + target: `${pythPackage}::contract_upgrade::commit_upgrade`, + arguments: [tx.object(contract.stateId), upgradeReceipt], + }); + + tx.setGasBudget(MIST_PER_SUI / 4n); // 0.25 SUI + + return provider.signAndExecuteTransaction({ + signer: keypair, + transaction: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} + +export async function migratePyth( + keypair: Ed25519Keypair, + provider: SuiClient, + signedUpgradeVaa: Buffer, + contract: SuiPriceFeedContract, + pythPackageOld: string +) { + const pythPackage = await contract.getPackageId(contract.stateId); + const tx = new Transaction(); + // The pyth package version is not updated yet, therefore we can not get the verification receipts from the new + // package yet. We need to use the old package id to get the verification receipt in this transaction and then submit + // it to the migrate function in the new package! + const verificationReceipt = await contract.getVaaVerificationReceipt( + tx, + pythPackageOld, + signedUpgradeVaa + ); + tx.moveCall({ + target: `${pythPackage}::migrate::migrate`, + arguments: [tx.object(contract.stateId), verificationReceipt as any], + }); + + tx.setGasBudget(MIST_PER_SUI / 10n); //0.1 SUI + + return provider.signAndExecuteTransaction({ + signer: keypair, + transaction: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} diff --git a/target_chains/iota/cli/tsconfig.json b/target_chains/iota/cli/tsconfig.json new file mode 100644 index 0000000000..be27cdded2 --- /dev/null +++ b/target_chains/iota/cli/tsconfig.json @@ -0,0 +1,9 @@ +{ + "extends": "../../../tsconfig.base.json", + "include": ["src"], + "exclude": ["node_modules", "**/__tests__/*"], + "compilerOptions": { + "rootDir": "src/", + "outDir": "./lib" + } +} diff --git a/target_chains/iota/contracts/Makefile b/target_chains/iota/contracts/Makefile new file mode 100644 index 0000000000..03eb12fe17 --- /dev/null +++ b/target_chains/iota/contracts/Makefile @@ -0,0 +1,9 @@ +TARGETS := test + +.PHONY: test +test: + sui move test + +.PHONY: build +build: + sui move build -d diff --git a/target_chains/iota/contracts/Move.iota_testnet.toml b/target_chains/iota/contracts/Move.iota_testnet.toml new file mode 100644 index 0000000000..e21819c7b3 --- /dev/null +++ b/target_chains/iota/contracts/Move.iota_testnet.toml @@ -0,0 +1,15 @@ +[package] +name = "Pyth" +version = "0.0.2" +published-at = "0x23994dd119480ea614f7623520337058dca913cb1bb6e5d8d51c7b067d3ca3bb" + +[dependencies.Iota] +git = "https://github.com/iotaledger/iota.git" +subdir = "crates/iota-framework/packages/iota-framework" +rev = "751c23caf24efd071463b9ffd07eabcb15f44f31" + +[dependencies.Wormhole] +local = "../vendor/wormhole_iota_testnet/wormhole" + +[addresses] +pyth = "0x23994dd119480ea614f7623520337058dca913cb1bb6e5d8d51c7b067d3ca3bb" diff --git a/target_chains/iota/contracts/Move.lock b/target_chains/iota/contracts/Move.lock new file mode 100644 index 0000000000..4d695c4552 --- /dev/null +++ b/target_chains/iota/contracts/Move.lock @@ -0,0 +1,36 @@ +# @generated by Move, please check-in and do not edit manually. + +[move] +version = 0 +manifest_digest = "915D6459031D76A0618631BDF08328171A3494876C5E17735BCBFF462BEDF464" +deps_digest = "3C4103934B1E040BB6B23F1D610B4EF9F2F1166A50A104EADCF77467C004C600" + +dependencies = [ + { name = "Iota" }, + { name = "Wormhole" }, +] + +[[move.package]] +name = "Iota" +source = { git = "https://github.com/iotaledger/iota.git", rev = "751c23caf24efd071463b9ffd07eabcb15f44f31", subdir = "crates/iota-framework/packages/iota-framework" } + +dependencies = [ + { name = "MoveStdlib" }, +] + +[[move.package]] +name = "MoveStdlib" +source = { git = "https://github.com/iotaledger/iota.git", rev = "751c23caf24efd071463b9ffd07eabcb15f44f31", subdir = "crates/iota-framework/packages/move-stdlib" } + +[[move.package]] +name = "Wormhole" +source = { local = "../vendor/wormhole_iota_testnet/wormhole" } + +dependencies = [ + { name = "Iota" }, +] + +[move.toolchain-version] +compiler-version = "0.9.2-rc" +edition = "2024.beta" +flavor = "iota" diff --git a/target_chains/iota/contracts/Move.mainnet.toml b/target_chains/iota/contracts/Move.mainnet.toml new file mode 100644 index 0000000000..d89bb0bf4b --- /dev/null +++ b/target_chains/iota/contracts/Move.mainnet.toml @@ -0,0 +1,17 @@ +[package] +name = "Pyth" +version = "0.0.2" +published-at = "0x04e20ddf36af412a4096f9014f4a565af9e812db9a05cc40254846cf6ed0ad91" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +git = "https://github.com/wormhole-foundation/wormhole.git" +subdir = "sui/wormhole" +rev = "sui-upgrade-mainnet" + +[addresses] +pyth = "0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e" diff --git a/target_chains/iota/contracts/Move.movement_m2_devnet.toml b/target_chains/iota/contracts/Move.movement_m2_devnet.toml new file mode 100644 index 0000000000..42fdd11c08 --- /dev/null +++ b/target_chains/iota/contracts/Move.movement_m2_devnet.toml @@ -0,0 +1,15 @@ +[package] +name = "Pyth" +version = "0.0.2" +published-at = "0x46522b54385efa424e0582ea4886bb5cfbe11d5c2a6a19ac0c82c2c81c73f9c5" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../vendor/wormhole_movement_m2_devnet/wormhole" + +[addresses] +pyth = "0x46522b54385efa424e0582ea4886bb5cfbe11d5c2a6a19ac0c82c2c81c73f9c5" diff --git a/target_chains/iota/contracts/Move.testnet.toml b/target_chains/iota/contracts/Move.testnet.toml new file mode 100644 index 0000000000..01a289f97e --- /dev/null +++ b/target_chains/iota/contracts/Move.testnet.toml @@ -0,0 +1,17 @@ +[package] +name = "Pyth" +version = "0.0.2" +published-at = "0xabf837e98c26087cba0883c0a7a28326b1fa3c5e1e2c5abdb486f9e8f594c837" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +git = "https://github.com/wormhole-foundation/wormhole.git" +subdir = "sui/wormhole" +rev = "sui-upgrade-testnet" + +[addresses] +pyth = "0xabf837e98c26087cba0883c0a7a28326b1fa3c5e1e2c5abdb486f9e8f594c837" diff --git a/target_chains/iota/contracts/Move.toml b/target_chains/iota/contracts/Move.toml new file mode 100644 index 0000000000..e21819c7b3 --- /dev/null +++ b/target_chains/iota/contracts/Move.toml @@ -0,0 +1,15 @@ +[package] +name = "Pyth" +version = "0.0.2" +published-at = "0x23994dd119480ea614f7623520337058dca913cb1bb6e5d8d51c7b067d3ca3bb" + +[dependencies.Iota] +git = "https://github.com/iotaledger/iota.git" +subdir = "crates/iota-framework/packages/iota-framework" +rev = "751c23caf24efd071463b9ffd07eabcb15f44f31" + +[dependencies.Wormhole] +local = "../vendor/wormhole_iota_testnet/wormhole" + +[addresses] +pyth = "0x23994dd119480ea614f7623520337058dca913cb1bb6e5d8d51c7b067d3ca3bb" diff --git a/target_chains/iota/contracts/README.md b/target_chains/iota/contracts/README.md new file mode 100644 index 0000000000..aaabaf1a9b --- /dev/null +++ b/target_chains/iota/contracts/README.md @@ -0,0 +1,18 @@ +# Build information + +Contracts are compiled with sui cli version `sui 1.0.0-09b208149` that can be installed via the following command: + +```commandline +cargo install --locked --git https://github.com/MystenLabs/sui.git --rev 09b2081498366df936abae26eea4b2d5cafb2788 sui sui-faucet +``` + +## Gas Profiling + +Using the [`sui-tool` binary](https://github.com/MystenLabs/sui/pull/12680), you can profile gas usage of transactions by running: + +```bash +env MOVE_VM_PROFILE=1 ./sui-tool replay --rpc https://fullnode.mainnet.sui.io:443 tx -t +``` + +`sui-tool` gas profiling works only when built with debug profile and should be compiled by your own (you can't use the precompiled binary). +We suggest benchmarking on mainnet or where the number of wormhole signature checks is the same as on mainnet. diff --git a/target_chains/iota/contracts/rust-toolchain.toml b/target_chains/iota/contracts/rust-toolchain.toml new file mode 100644 index 0000000000..83025f9721 --- /dev/null +++ b/target_chains/iota/contracts/rust-toolchain.toml @@ -0,0 +1,2 @@ +[toolchain] +channel = "1.77.0" diff --git a/target_chains/iota/contracts/sources/batch_price_attestation.move b/target_chains/iota/contracts/sources/batch_price_attestation.move new file mode 100644 index 0000000000..461c8daac3 --- /dev/null +++ b/target_chains/iota/contracts/sources/batch_price_attestation.move @@ -0,0 +1,247 @@ +module pyth::batch_price_attestation { + use std::vector::{Self}; + use iota::clock::{Self, Clock}; + + use pyth::price_feed::{Self}; + use pyth::price_info::{Self, PriceInfo}; + use pyth::price_identifier::{Self}; + use pyth::price_status; + use pyth::deserialize::{Self}; + + use wormhole::cursor::{Self, Cursor}; + use wormhole::bytes::{Self}; + + #[test_only] + use pyth::price; + #[test_only] + use pyth::i64; + + const MAGIC: u64 = 0x50325748; // "P2WH" (Pyth2Wormhole) raw ASCII bytes + const E_INVALID_ATTESTATION_MAGIC_VALUE: u64 = 0; + const E_INVALID_BATCH_ATTESTATION_HEADER_SIZE: u64 = 1; + + /// @notice This struct is based on the legacy wormhole attester implementation in pythnet_sdk + struct BatchPriceAttestation { + header: Header, + attestation_size: u64, + attestation_count: u64, + price_infos: vector, + } + + struct Header { + magic: u64, + version_major: u64, + version_minor: u64, + header_size: u64, + payload_id: u8, + } + + fun deserialize_header(cur: &mut Cursor): Header { + let magic = (deserialize::deserialize_u32(cur) as u64); + assert!(magic == MAGIC, E_INVALID_ATTESTATION_MAGIC_VALUE); + let version_major = deserialize::deserialize_u16(cur); + let version_minor = deserialize::deserialize_u16(cur); + let header_size = deserialize::deserialize_u16(cur); + let payload_id = deserialize::deserialize_u8(cur); + + assert!(header_size >= 1, E_INVALID_BATCH_ATTESTATION_HEADER_SIZE); + let unknown_header_bytes = header_size - 1; + let _unknown = bytes::take_bytes(cur, (unknown_header_bytes as u64)); + + Header { + magic, + header_size: (header_size as u64), + version_minor: (version_minor as u64), + version_major: (version_major as u64), + payload_id, + } + } + + public fun destroy(batch: BatchPriceAttestation): vector { + let BatchPriceAttestation { + header: Header { + magic: _, + version_major: _, + version_minor: _, + header_size: _, + payload_id: _, + }, + attestation_size: _, + attestation_count: _, + price_infos, + } = batch; + price_infos + } + + public fun get_attestation_count(batch: &BatchPriceAttestation): u64 { + batch.attestation_count + } + + public fun get_price_info(batch: &BatchPriceAttestation, index: u64): &PriceInfo { + vector::borrow(&batch.price_infos, index) + } + + public fun deserialize(bytes: vector, clock: &Clock): BatchPriceAttestation { + let cur = cursor::new(bytes); + let header = deserialize_header(&mut cur); + + let attestation_count = deserialize::deserialize_u16(&mut cur); + let attestation_size = deserialize::deserialize_u16(&mut cur); + let price_infos = vector::empty(); + + let i = 0; + while (i < attestation_count) { + let price_info = deserialize_price_info(&mut cur, clock); + vector::push_back(&mut price_infos, price_info); + + // Consume any excess bytes + let parsed_bytes = 32+32+8+8+4+8+8+1+4+4+8+8+8+8+8; + let _excess = bytes::take_bytes(&mut cur, (attestation_size - parsed_bytes as u64)); + + i = i + 1; + }; + cursor::destroy_empty(cur); + + BatchPriceAttestation { + header, + attestation_count: (attestation_count as u64), + attestation_size: (attestation_size as u64), + price_infos, + } + } + + fun deserialize_price_info(cur: &mut Cursor, clock: &Clock): PriceInfo { + + // Skip obsolete field + let _product_identifier = deserialize::deserialize_vector(cur, 32); + let price_identifier = price_identifier::from_byte_vec(deserialize::deserialize_vector(cur, 32)); + let price = deserialize::deserialize_i64(cur); + let conf = deserialize::deserialize_u64(cur); + let expo = deserialize::deserialize_i32(cur); + let ema_price = deserialize::deserialize_i64(cur); + let ema_conf = deserialize::deserialize_u64(cur); + let status = price_status::from_u64((deserialize::deserialize_u8(cur) as u64)); + + // Skip obsolete fields + let _num_publishers = deserialize::deserialize_u32(cur); + let _max_num_publishers = deserialize::deserialize_u32(cur); + + let attestation_time = deserialize::deserialize_u64(cur); + let publish_time = deserialize::deserialize_u64(cur); // + let prev_publish_time = deserialize::deserialize_u64(cur); + let prev_price = deserialize::deserialize_i64(cur); + let prev_conf = deserialize::deserialize_u64(cur); + + // Handle the case where the status is not trading. This logic will soon be moved into + // the attester. + + // If status is trading, use the current price. + // If not, use the last known trading price. + let current_price = pyth::price::new(price, conf, expo, publish_time); + if (status != price_status::new_trading()) { + current_price = pyth::price::new(prev_price, prev_conf, expo, prev_publish_time); + }; + + // If status is trading, use the timestamp of the aggregate as the timestamp for the + // EMA price. If not, the EMA will have last been updated when the aggregate last had + // trading status, so use prev_publish_time (the time when the aggregate last had trading status). + let ema_timestamp = publish_time; + if (status != price_status::new_trading()) { + ema_timestamp = prev_publish_time; + }; + + price_info::new_price_info( + attestation_time, + clock::timestamp_ms(clock) / 1000, // Divide by 1000 to get timestamp in seconds + price_feed::new( + price_identifier, + current_price, + pyth::price::new(ema_price, ema_conf, expo, ema_timestamp), + ) + ) + } + + #[test] + #[expected_failure] + fun test_deserialize_batch_price_attestation_invalid_magic() { + use iota::test_scenario::{Self, ctx}; + let test = test_scenario::begin(@0x1234); + let test_clock = clock::create_for_testing(ctx(&mut test)); + // A batch price attestation with a magic number of 0x50325749 + let bytes = x"5032574900030000000102000400951436e0be37536be96f0896366089506a59763d036728332d3e3038047851aea7c6c75c89f14810ec1c54c03ab8f1864a4c4032791f05747f560faec380a695d1000000000000049a0000000000000008fffffffb00000000000005dc0000000000000003000000000100000001000000006329c0eb000000006329c0e9000000006329c0e400000000000006150000000000000007215258d81468614f6b7e194c5d145609394f67b041e93e6695dcc616faadd0603b9551a68d01d954d6387aff4df1529027ffb2fee413082e509feb29cc4904fe000000000000041a0000000000000003fffffffb00000000000005cb0000000000000003010000000100000001000000006329c0eb000000006329c0e9000000006329c0e4000000000000048600000000000000078ac9cf3ab299af710d735163726fdae0db8465280502eb9f801f74b3c1bd190333832fad6e36eb05a8972fe5f219b27b5b2bb2230a79ce79beb4c5c5e7ecc76d00000000000003f20000000000000002fffffffb00000000000005e70000000000000003010000000100000001000000006329c0eb000000006329c0e9000000006329c0e40000000000000685000000000000000861db714e9ff987b6fedf00d01f9fea6db7c30632d6fc83b7bc9459d7192bc44a21a28b4c6619968bd8c20e95b0aaed7df2187fd310275347e0376a2cd7427db800000000000006cb0000000000000001fffffffb00000000000005e40000000000000003010000000100000001000000006329c0eb000000006329c0e9000000006329c0e400000000000007970000000000000001"; + let _ = destroy(deserialize(bytes, &test_clock)); + clock::destroy_for_testing(test_clock); + test_scenario::end(test); + } + + #[test] + fun test_deserialize_batch_price_attestation() { + use iota::test_scenario::{Self, ctx}; + // Set the arrival time + let test = test_scenario::begin(@0x1234); + let test_clock = clock::create_for_testing(ctx(&mut test)); + test_scenario::next_tx(&mut test, @0x1234); + let arrival_time_in_seconds = clock::timestamp_ms(&test_clock) / 1000; + + // let arrival_time = tx_context::epoch(ctx(&mut test)); + + // A raw batch price attestation + // The first attestation has a status of UNKNOWN + let bytes = x"5032574800030000000102000400951436e0be37536be96f0896366089506a59763d036728332d3e3038047851aea7c6c75c89f14810ec1c54c03ab8f1864a4c4032791f05747f560faec380a695d1000000000000049a0000000000000008fffffffb00000000000005dc0000000000000003000000000100000001000000006329c0eb000000006329c0e9000000006329c0e400000000000006150000000000000007215258d81468614f6b7e194c5d145609394f67b041e93e6695dcc616faadd0603b9551a68d01d954d6387aff4df1529027ffb2fee413082e509feb29cc4904fe000000000000041a0000000000000003fffffffb00000000000005cb0000000000000003010000000100000001000000006329c0eb000000006329c0e9000000006329c0e4000000000000048600000000000000078ac9cf3ab299af710d735163726fdae0db8465280502eb9f801f74b3c1bd190333832fad6e36eb05a8972fe5f219b27b5b2bb2230a79ce79beb4c5c5e7ecc76d00000000000003f20000000000000002fffffffb00000000000005e70000000000000003010000000100000001000000006329c0eb000000006329c0e9000000006329c0e40000000000000685000000000000000861db714e9ff987b6fedf00d01f9fea6db7c30632d6fc83b7bc9459d7192bc44a21a28b4c6619968bd8c20e95b0aaed7df2187fd310275347e0376a2cd7427db800000000000006cb0000000000000001fffffffb00000000000005e40000000000000003010000000100000001000000006329c0eb000000006329c0e9000000006329c0e400000000000007970000000000000001"; + + let expected = BatchPriceAttestation { + header: Header { + magic: 0x50325748, + version_major: 3, + version_minor: 0, + payload_id: 2, + header_size: 1, + }, + attestation_count: 4, + attestation_size: 149, + price_infos: vector[ + price_info::new_price_info( + 1663680747, + arrival_time_in_seconds, + price_feed::new( + price_identifier::from_byte_vec(x"c6c75c89f14810ec1c54c03ab8f1864a4c4032791f05747f560faec380a695d1"), + price::new(i64::new(1557, false), 7, i64::new(5, true), 1663680740), + price::new(i64::new(1500, false), 3, i64::new(5, true), 1663680740), + ) ), + price_info::new_price_info( + 1663680747, + arrival_time_in_seconds, + price_feed::new( + price_identifier::from_byte_vec(x"3b9551a68d01d954d6387aff4df1529027ffb2fee413082e509feb29cc4904fe"), + price::new(i64::new(1050, false), 3, i64::new(5, true), 1663680745), + price::new(i64::new(1483, false), 3, i64::new(5, true), 1663680745), + ) ), + price_info::new_price_info( + 1663680747, + arrival_time_in_seconds, + price_feed::new( + price_identifier::from_byte_vec(x"33832fad6e36eb05a8972fe5f219b27b5b2bb2230a79ce79beb4c5c5e7ecc76d"), + price::new(i64::new(1010, false), 2, i64::new(5, true), 1663680745), + price::new(i64::new(1511, false), 3, i64::new(5, true), 1663680745), + ) ), + price_info::new_price_info( + 1663680747, + arrival_time_in_seconds, + price_feed::new( + price_identifier::from_byte_vec(x"21a28b4c6619968bd8c20e95b0aaed7df2187fd310275347e0376a2cd7427db8"), + price::new(i64::new(1739, false), 1, i64::new(5, true), 1663680745), + price::new(i64::new(1508, false), 3, i64::new(5, true), 1663680745), + ) + ), + ], + }; + + let deserialized = deserialize(bytes, &test_clock); + + assert!(&expected == &deserialized, 1); + destroy(expected); + destroy(deserialized); + clock::destroy_for_testing(test_clock); + test_scenario::end(test); + } +} diff --git a/target_chains/iota/contracts/sources/data_source.move b/target_chains/iota/contracts/sources/data_source.move new file mode 100644 index 0000000000..2b7e4a56e9 --- /dev/null +++ b/target_chains/iota/contracts/sources/data_source.move @@ -0,0 +1,85 @@ +module pyth::data_source { + use iota::dynamic_field::{Self}; + use iota::object::{UID}; + use iota::tx_context::{TxContext}; + + use pyth::set::{Self}; + + use wormhole::external_address::ExternalAddress; + + friend pyth::state; + friend pyth::set_data_sources; + friend pyth::pyth; + friend pyth::set_governance_data_source; + friend pyth::governance; + #[test_only] + friend pyth::pyth_tests; + #[test_only] + friend pyth::set_data_sources_tests; + + const KEY: vector = b"data_sources"; + const E_DATA_SOURCE_REGISTRY_ALREADY_EXISTS: u64 = 0; + const E_DATA_SOURCE_ALREADY_REGISTERED: u64 = 1; + + struct DataSource has copy, drop, store { + emitter_chain: u64, + emitter_address: ExternalAddress, + } + + public(friend) fun new_data_source_registry(parent_id: &mut UID, ctx: &mut TxContext) { + assert!( + !dynamic_field::exists_(parent_id, KEY), + E_DATA_SOURCE_REGISTRY_ALREADY_EXISTS // TODO - add custom error type + ); + dynamic_field::add( + parent_id, + KEY, + set::new(ctx) + ) + } + + public(friend) fun add(parent_id: &mut UID, data_source: DataSource) { + assert!( + !contains(parent_id, data_source), + E_DATA_SOURCE_ALREADY_REGISTERED + ); + set::add( + dynamic_field::borrow_mut(parent_id, KEY), + data_source + ) + } + + public(friend) fun empty(parent_id: &mut UID){ + set::empty( + dynamic_field::borrow_mut(parent_id, KEY) + ) + } + + public fun contains(parent_id: &UID, data_source: DataSource): bool { + let ref = dynamic_field::borrow(parent_id, KEY); + set::contains(ref, data_source) + } + + public(friend) fun new(emitter_chain: u64, emitter_address: ExternalAddress): DataSource { + DataSource { + emitter_chain, + emitter_address, + } + } + + public fun emitter_chain(data_source: &DataSource): u64{ + data_source.emitter_chain + } + + public fun emitter_address(data_source: &DataSource): ExternalAddress{ + data_source.emitter_address + } + + #[test_only] + public fun new_data_source_for_test(emitter_chain: u64, emitter_address: ExternalAddress): DataSource { + DataSource { + emitter_chain, + emitter_address, + } + } +} diff --git a/target_chains/iota/contracts/sources/deserialize.move b/target_chains/iota/contracts/sources/deserialize.move new file mode 100644 index 0000000000..310107d6ea --- /dev/null +++ b/target_chains/iota/contracts/sources/deserialize.move @@ -0,0 +1,143 @@ + module pyth::deserialize { + use wormhole::bytes::{Self}; + use wormhole::cursor::{Cursor}; + use pyth::i64::{Self, I64}; + #[test_only] + use wormhole::cursor::{take_rest}; + + #[test_only] + use wormhole::cursor::{Self}; + + public fun deserialize_vector(cur: &mut Cursor, n: u64): vector { + bytes::take_bytes(cur, n) + } + + public fun deserialize_u8(cur: &mut Cursor): u8 { + bytes::take_u8(cur) + } + + public fun deserialize_u16(cur: &mut Cursor): u16 { + bytes::take_u16_be(cur) + } + + public fun deserialize_u32(cur: &mut Cursor): u32 { + bytes::take_u32_be(cur) + } + + public fun deserialize_i32(cur: &mut Cursor): I64 { + let deserialized = deserialize_u32(cur); + // If negative, pad the value + let negative = (deserialized >> 31) == 1; + if (negative) { + let padded = (0xFFFFFFFF << 32) + (deserialized as u64); + i64::from_u64((padded as u64)) + } else { + i64::from_u64((deserialized as u64)) + } + } + + public fun deserialize_u64(cur: &mut Cursor): u64 { + bytes::take_u64_be(cur) + } + + public fun deserialize_i64(cur: &mut Cursor): I64 { + i64::from_u64(deserialize_u64(cur)) + } + + #[test] + fun test_deserialize_u8() { + let input = x"48258963"; + let cursor = cursor::new(input); + + let result = deserialize_u8(&mut cursor); + assert!(result == 0x48, 1); + + let rest = take_rest(cursor); + assert!(rest == x"258963", 1); + } + + #[test] + fun test_deserialize_u16() { + let input = x"48258963"; + let cursor = cursor::new(input); + + let result = deserialize_u16(&mut cursor); + assert!(result == 0x4825, 1); + + let rest = take_rest(cursor); + assert!(rest == x"8963", 1); + } + + #[test] + fun test_deserialize_u32() { + let input = x"4825896349741695"; + let cursor = cursor::new(input); + + let result = deserialize_u32(&mut cursor); + assert!(result == 0x48258963, 1); + + let rest = take_rest(cursor); + assert!(rest == x"49741695", 1); + } + + #[test] + fun test_deserialize_i32_positive() { + let input = x"4825896349741695"; + let cursor = cursor::new(input); + + let result = deserialize_i32(&mut cursor); + assert!(result == i64::from_u64(0x48258963), 1); + + let rest = take_rest(cursor); + assert!(rest == x"49741695", 1); + } + + #[test] + fun test_deserialize_i32_negative() { + let input = x"FFFFFDC349741695"; + + let cursor = cursor::new(input); + + let result = deserialize_i32(&mut cursor); + assert!(result == i64::from_u64(0xFFFFFFFFFFFFFDC3), 1); + + let rest = take_rest(cursor); + assert!(rest == x"49741695", 1); + } + + #[test] + fun test_deserialize_u64() { + let input = x"48258963497416957497253486"; + let cursor = cursor::new(input); + + let result = deserialize_u64(&mut cursor); + assert!(result == 0x4825896349741695, 1); + + let rest = take_rest(cursor); + assert!(rest == x"7497253486", 1); + } + + #[test] + fun test_deserialize_i64_positive() { + let input = x"48258963497416957497253486"; + let cursor = cursor::new(input); + + let result = deserialize_i64(&mut cursor); + assert!(result == i64::from_u64(0x4825896349741695), 1); + + let rest = take_rest(cursor); + assert!(rest == x"7497253486", 1); + } + + #[test] + fun test_deserialize_i64_negative() { + let input = x"FFFFFFFFFFFFFDC37497253486"; + let cursor = cursor::new(input); + + let result = deserialize_i64(&mut cursor); + assert!(result == i64::from_u64(0xFFFFFFFFFFFFFDC3), 1); + + let rest = take_rest(cursor); + assert!(rest == x"7497253486", 1); + } +} diff --git a/target_chains/iota/contracts/sources/event.move b/target_chains/iota/contracts/sources/event.move new file mode 100644 index 0000000000..ab23be344d --- /dev/null +++ b/target_chains/iota/contracts/sources/event.move @@ -0,0 +1,33 @@ +module pyth::event { + use iota::event::{Self}; + use pyth::price_feed::{PriceFeed}; + + friend pyth::pyth; + friend pyth::state; + + struct PythInitializationEvent has copy, drop {} + + /// Signifies that a price feed has been updated + struct PriceFeedUpdateEvent has copy, store, drop { + /// Value of the price feed + price_feed: PriceFeed, + /// Timestamp of the update + timestamp: u64, + } + + public(friend) fun emit_price_feed_update(price_feed: PriceFeed, timestamp: u64 /* in seconds */) { + event::emit( + PriceFeedUpdateEvent { + price_feed, + timestamp, + } + ); + } + + public(friend) fun emit_pyth_initialization_event() { + event::emit( + PythInitializationEvent {} + ); + } + +} diff --git a/target_chains/iota/contracts/sources/governance/contract_upgrade.move b/target_chains/iota/contracts/sources/governance/contract_upgrade.move new file mode 100644 index 0000000000..5f1918dff1 --- /dev/null +++ b/target_chains/iota/contracts/sources/governance/contract_upgrade.move @@ -0,0 +1,145 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact upgrading the +/// Pyth contract to a new build. The procedure to upgrade this contract +/// requires a Programmable Transaction, which includes the following procedure: +/// 1. Load new build. +/// 2. Authorize upgrade. +/// 3. Upgrade. +/// 4. Commit upgrade. +module pyth::contract_upgrade { + use iota::event::{Self}; + use iota::object::{ID}; + use iota::package::{UpgradeReceipt, UpgradeTicket}; + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::cursor::{Self}; + + use pyth::state::{Self, State}; + use pyth::governance_instruction::{Self}; + use pyth::governance_action::{Self}; + use pyth::governance::{Self, WormholeVAAVerificationReceipt}; + + friend pyth::migrate; + + /// Digest is all zeros. + const E_DIGEST_ZERO_BYTES: u64 = 0; + const E_GOVERNANCE_ACTION_MUST_BE_CONTRACT_UPGRADE: u64 = 1; + const E_GOVERNANCE_CONTRACT_UPGRADE_CHAIN_ID_ZERO: u64 = 2; + const E_CANNOT_EXECUTE_GOVERNANCE_ACTION_WITH_OBSOLETE_SEQUENCE_NUMBER: u64 = 3; + + // Event reflecting package upgrade. + struct ContractUpgraded has drop, copy { + old_contract: ID, + new_contract: ID + } + + struct UpgradeContract { + digest: Bytes32 + } + + /// Redeem governance VAA to issue an `UpgradeTicket` for the upgrade given + /// a contract upgrade VAA. This governance message is only relevant for Iota + /// because a contract upgrade is only relevant to one particular network + /// (in this case Iota), whose build digest is encoded in this message. + public fun authorize_upgrade( + pyth_state: &mut State, + receipt: WormholeVAAVerificationReceipt, + ): UpgradeTicket { + + // Get the sequence number of the governance VAA that was used to + // generate the receipt. + let sequence = governance::take_sequence(&receipt); + + // Require that new sequence number is greater than last executed sequence number. + assert!(sequence > state::get_last_executed_governance_sequence(pyth_state), + E_CANNOT_EXECUTE_GOVERNANCE_ACTION_WITH_OBSOLETE_SEQUENCE_NUMBER); + + // Update latest executed sequence number to current one. + state::set_last_executed_governance_sequence_unchecked(pyth_state, sequence); + + let digest = take_upgrade_digest(receipt); + // Proceed with processing new implementation version. + handle_upgrade_contract(pyth_state, digest) + } + + + public(friend) fun take_upgrade_digest(receipt: WormholeVAAVerificationReceipt): Bytes32 { + let payload = governance::take_payload(&receipt); + + let instruction = governance_instruction::from_byte_vec(payload); + + // Get the governance action. + let action = governance_instruction::get_action(&instruction); + + assert!(action == governance_action::new_contract_upgrade(), + E_GOVERNANCE_ACTION_MUST_BE_CONTRACT_UPGRADE); + + assert!(governance_instruction::get_target_chain_id(&instruction) != 0, + E_GOVERNANCE_CONTRACT_UPGRADE_CHAIN_ID_ZERO); + + governance::destroy(receipt); + // upgrade_payload contains a 32-byte digest + let upgrade_payload = governance_instruction::destroy(instruction); + + take_digest(upgrade_payload) + } + + /// Finalize the upgrade that ran to produce the given `receipt`. This + /// method invokes `state::commit_upgrade` which interacts with + /// `iota::package`. + public fun commit_upgrade( + self: &mut State, + receipt: UpgradeReceipt, + ) { + let (old_contract, new_contract) = state::commit_upgrade(self, receipt); + + // Emit an event reflecting package ID change. + event::emit(ContractUpgraded { old_contract, new_contract }); + } + + /// Privileged method only to be used by this module and `migrate` module. + /// + /// During migration, we make sure that the digest equals what we expect by + /// passing in the same VAA used to upgrade the package. + public(friend) fun take_digest(governance_payload: vector): Bytes32 { + // Deserialize the payload as the build digest. + let UpgradeContract { digest } = deserialize(governance_payload); + + digest + } + + fun handle_upgrade_contract( + pyth_state: &mut State, + digest: Bytes32 + ): UpgradeTicket { + state::authorize_upgrade(pyth_state, digest) + } + + fun deserialize(payload: vector): UpgradeContract { + let cur = cursor::new(payload); + let digest = bytes32::take_bytes(&mut cur); + assert!(bytes32::is_nonzero(&digest), E_DIGEST_ZERO_BYTES); + + // there might be additional appended to payload in the future, + // which is why we don't cursor::destroy_empty(&mut cur) + cursor::take_rest(cur); + UpgradeContract { digest } + } + + #[test_only] + /// Specific governance payload ID (action) to complete upgrading the + /// contract. + /// TODO: is it okay for the contract upgrade action for Pyth to be 0? Or should it be 1? + const CONTRACT_UPGRADE: u8 = 0; + + + #[test_only] + public fun action(): u8 { + CONTRACT_UPGRADE + } +} + +#[test_only] +module pyth::upgrade_contract_tests { + // TODO +} diff --git a/target_chains/iota/contracts/sources/governance/governance.move b/target_chains/iota/contracts/sources/governance/governance.move new file mode 100644 index 0000000000..c09b031a6b --- /dev/null +++ b/target_chains/iota/contracts/sources/governance/governance.move @@ -0,0 +1,116 @@ +module pyth::governance { + use pyth::governance_instruction; + use pyth::governance_action; + use pyth::set_governance_data_source; + use pyth::set_data_sources; + use pyth::set_stale_price_threshold; + use pyth::set_fee_recipient; + use pyth::state::{Self, State}; + use pyth::set_update_fee; + + use wormhole::vaa::{Self, VAA}; + use wormhole::bytes32::Bytes32; + + const E_INVALID_GOVERNANCE_ACTION: u64 = 0; + const E_MUST_USE_CONTRACT_UPGRADE_MODULE_TO_DO_UPGRADES: u64 = 1; + const E_CANNOT_EXECUTE_GOVERNANCE_ACTION_WITH_OBSOLETE_SEQUENCE_NUMBER: u64 = 2; + const E_INVALID_GOVERNANCE_DATA_SOURCE: u64 = 4; + + // this struct does not have the store or key ability so it must be + // used in the same txn chain in which it is created + struct WormholeVAAVerificationReceipt{ + payload: vector, + digest: Bytes32, + sequence: u64, // used for replay protection + } + + public fun take_payload(receipt: &WormholeVAAVerificationReceipt): vector { + receipt.payload + } + + public fun take_digest(receipt: &WormholeVAAVerificationReceipt): Bytes32 { + receipt.digest + } + + public fun take_sequence(receipt: &WormholeVAAVerificationReceipt): u64 { + receipt.sequence + } + + public fun destroy(receipt: WormholeVAAVerificationReceipt) { + let WormholeVAAVerificationReceipt{payload: _, digest: _, sequence: _} = receipt; + } + + // We define a custom verify_vaa function instead of using wormhole::governance_message::verify_vaa + // because that function makes extra assumptions about the VAA payload headers. Pyth uses a + // different header format compared to Wormhole, so + public fun verify_vaa( + pyth_state: &State, + verified_vaa: VAA, + ): WormholeVAAVerificationReceipt { + state::assert_latest_only(pyth_state); + + let vaa_data_source = pyth::data_source::new((vaa::emitter_chain(&verified_vaa) as u64), vaa::emitter_address(&verified_vaa)); + + // The emitter chain and address must correspond to the Pyth governance emitter chain and contract. + assert!( + pyth::state::is_valid_governance_data_source(pyth_state, vaa_data_source), + E_INVALID_GOVERNANCE_DATA_SOURCE + ); + + let digest = vaa::digest(&verified_vaa); + + let sequence = vaa::sequence(&verified_vaa); + + let payload = vaa::take_payload(verified_vaa); + + WormholeVAAVerificationReceipt { payload, digest, sequence } + } + + /// Execute a governance instruction other than contract upgrade, which is + /// handled separately in the contract_upgrade.move module. + public fun execute_governance_instruction( + pyth_state : &mut State, + receipt: WormholeVAAVerificationReceipt, + ) { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(pyth_state); + + // Get the sequence number of the governance VAA that was used to + // generate the receipt. + let sequence = receipt.sequence; + + // Require that new sequence number is greater than last executed sequence number. + assert!(sequence > state::get_last_executed_governance_sequence(pyth_state), + E_CANNOT_EXECUTE_GOVERNANCE_ACTION_WITH_OBSOLETE_SEQUENCE_NUMBER); + + // Update latest executed sequence number to current one. + state::set_last_executed_governance_sequence(&latest_only, pyth_state, sequence); + + let payload = receipt.payload; + + destroy(receipt); + + let instruction = governance_instruction::from_byte_vec(payload); + + // Get the governance action. + let action = governance_instruction::get_action(&instruction); + + // Dispatch the instruction to the appropriate handler. + if (action == governance_action::new_contract_upgrade()) { + abort(E_MUST_USE_CONTRACT_UPGRADE_MODULE_TO_DO_UPGRADES) + } else if (action == governance_action::new_set_governance_data_source()) { + set_governance_data_source::execute(&latest_only, pyth_state, governance_instruction::destroy(instruction)); + } else if (action == governance_action::new_set_data_sources()) { + set_data_sources::execute(&latest_only, pyth_state, governance_instruction::destroy(instruction)); + } else if (action == governance_action::new_set_update_fee()) { + set_update_fee::execute(&latest_only, pyth_state, governance_instruction::destroy(instruction)); + } else if (action == governance_action::new_set_stale_price_threshold()) { + set_stale_price_threshold::execute(&latest_only, pyth_state, governance_instruction::destroy(instruction)); + } else if (action == governance_action::new_set_fee_recipient()) { + set_fee_recipient::execute(&latest_only, pyth_state, governance_instruction::destroy(instruction)); + } else { + governance_instruction::destroy(instruction); + assert!(false, E_INVALID_GOVERNANCE_ACTION); + } + } +} diff --git a/target_chains/iota/contracts/sources/governance/governance_action.move b/target_chains/iota/contracts/sources/governance/governance_action.move new file mode 100644 index 0000000000..6bfce10a50 --- /dev/null +++ b/target_chains/iota/contracts/sources/governance/governance_action.move @@ -0,0 +1,48 @@ +module pyth::governance_action { + + const CONTRACT_UPGRADE: u8 = 0; + const SET_GOVERNANCE_DATA_SOURCE: u8 = 1; + const SET_DATA_SOURCES: u8 = 2; + const SET_UPDATE_FEE: u8 = 3; + const SET_STALE_PRICE_THRESHOLD: u8 = 4; + const SET_FEE_RECIPIENT: u8 = 5; + + const E_INVALID_GOVERNANCE_ACTION: u64 = 6; + + struct GovernanceAction has copy, drop { + value: u8, + } + + public fun from_u8(value: u8): GovernanceAction { + assert!(CONTRACT_UPGRADE <= value && value <= SET_FEE_RECIPIENT, E_INVALID_GOVERNANCE_ACTION); + GovernanceAction { value } + } + + public fun get_value(a: GovernanceAction): u8{ + a.value + } + + public fun new_contract_upgrade(): GovernanceAction { + GovernanceAction { value: CONTRACT_UPGRADE } + } + + public fun new_set_governance_data_source(): GovernanceAction { + GovernanceAction { value: SET_GOVERNANCE_DATA_SOURCE } + } + + public fun new_set_data_sources(): GovernanceAction { + GovernanceAction { value: SET_DATA_SOURCES } + } + + public fun new_set_update_fee(): GovernanceAction { + GovernanceAction { value: SET_UPDATE_FEE } + } + + public fun new_set_stale_price_threshold(): GovernanceAction { + GovernanceAction { value: SET_STALE_PRICE_THRESHOLD } + } + + public fun new_set_fee_recipient(): GovernanceAction { + GovernanceAction { value: SET_FEE_RECIPIENT } + } +} diff --git a/target_chains/iota/contracts/sources/governance/governance_instruction.move b/target_chains/iota/contracts/sources/governance/governance_instruction.move new file mode 100644 index 0000000000..ee008308e7 --- /dev/null +++ b/target_chains/iota/contracts/sources/governance/governance_instruction.move @@ -0,0 +1,91 @@ +module pyth::governance_instruction { + use wormhole::cursor; + use pyth::deserialize; + use pyth::governance_action::{Self, GovernanceAction}; + + const MAGIC: vector = x"5054474d"; // "PTGM": Pyth Governance Message + const MODULE: u8 = 1; + + const E_INVALID_GOVERNANCE_MODULE: u64 = 0; + const E_INVALID_GOVERNANCE_MAGIC_VALUE: u64 = 1; + const E_TARGET_CHAIN_MISMATCH: u64 = 2; + + struct GovernanceInstruction { + module_: u8, + action: GovernanceAction, + target_chain_id: u64, + payload: vector, + } + + fun validate(instruction: &GovernanceInstruction) { + assert!(instruction.module_ == MODULE, E_INVALID_GOVERNANCE_MODULE); + let target_chain_id = instruction.target_chain_id; + assert!(target_chain_id == (wormhole::state::chain_id() as u64) || target_chain_id == 0, E_TARGET_CHAIN_MISMATCH); + } + + public fun from_byte_vec(bytes: vector): GovernanceInstruction { + let cursor = cursor::new(bytes); + let magic = deserialize::deserialize_vector(&mut cursor, 4); + assert!(magic == MAGIC, E_INVALID_GOVERNANCE_MAGIC_VALUE); + // "module" is a reserved keyword, so we use "module_" instead. + let module_ = deserialize::deserialize_u8(&mut cursor); + let action = governance_action::from_u8(deserialize::deserialize_u8(&mut cursor)); + let target_chain_id = deserialize::deserialize_u16(&mut cursor); + let payload = cursor::take_rest(cursor); + + let instruction = GovernanceInstruction { + module_, + action, + target_chain_id : (target_chain_id as u64), + payload + }; + + // validate validates that module and target chain are correct + validate(&instruction); + + instruction + } + + public fun get_module(instruction: &GovernanceInstruction): u8 { + instruction.module_ + } + + public fun get_action(instruction: &GovernanceInstruction): GovernanceAction { + instruction.action + } + + public fun get_target_chain_id(instruction: &GovernanceInstruction): u64 { + instruction.target_chain_id + } + + public fun destroy(instruction: GovernanceInstruction): vector { + let GovernanceInstruction { + module_: _, + action: _, + target_chain_id: _, + payload + } = instruction; + payload + } + + #[test] + #[expected_failure] + fun test_from_byte_vec_invalid_magic() { + let bytes = x"5054474eb01087a85361f738f19454e66664d3c9"; + destroy(from_byte_vec(bytes)); + } + + #[test] + #[expected_failure] + fun test_from_byte_vec_invalid_module() { + let bytes = x"5054474db00187a85361f738f19454e66664d3c9"; + destroy(from_byte_vec(bytes)); + } + + #[test] + #[expected_failure] + fun test_from_byte_vec_invalid_target_chain_id() { + let bytes = x"5054474db00187a85361f738f19454e66664d3c9"; + destroy(from_byte_vec(bytes)); + } +} diff --git a/target_chains/iota/contracts/sources/governance/set_data_sources.move b/target_chains/iota/contracts/sources/governance/set_data_sources.move new file mode 100644 index 0000000000..e3fbe4287a --- /dev/null +++ b/target_chains/iota/contracts/sources/governance/set_data_sources.move @@ -0,0 +1,100 @@ +module pyth::set_data_sources { + use std::vector; + + use wormhole::cursor; + use wormhole::external_address::{Self}; + use wormhole::bytes32::{Self}; + + use pyth::deserialize; + use pyth::data_source::{Self, DataSource}; + use pyth::state::{Self, State, LatestOnly}; + + friend pyth::governance; + + struct DataSources { + sources: vector, + } + + public(friend) fun execute( + latest_only: &LatestOnly, + state: &mut State, + payload: vector + ) { + let DataSources { sources } = from_byte_vec(payload); + state::set_data_sources(latest_only, state, sources); + } + + fun from_byte_vec(bytes: vector): DataSources { + let cursor = cursor::new(bytes); + let data_sources_count = deserialize::deserialize_u8(&mut cursor); + + let sources = vector::empty(); + + let i = 0; + while (i < data_sources_count) { + let emitter_chain_id = deserialize::deserialize_u16(&mut cursor); + let emitter_address = external_address::new(bytes32::from_bytes(deserialize::deserialize_vector(&mut cursor, 32))); + vector::push_back(&mut sources, data_source::new((emitter_chain_id as u64), emitter_address)); + + i = i + 1; + }; + + cursor::destroy_empty(cursor); + + DataSources { + sources + } + } +} + +#[test_only] +module pyth::set_data_sources_tests { + use iota::test_scenario::{Self}; + use iota::coin::Self; + + use wormhole::external_address::{Self}; + use wormhole::bytes32::{Self}; + + use pyth::pyth_tests::{Self, setup_test, take_wormhole_and_pyth_states}; + use pyth::state::Self; + use pyth::data_source::Self; + + const SET_DATA_SOURCES_VAA: vector = x"01000000000100b29ee59868b9066b04d8d59e1c7cc66f0678eaf4c58b8c87e4405d6de615f64b04da4025719aeed349e03900f37829454d62cc7fc7bca80328c31fe40be7b21b010000000000000000000163278d271099bfd491951b3e648f08b1c71631e4a53674ad43e8f9f98068c3850000000000000001015054474d0102001503001ae101faedac5851e32b9b23b5f9411a8c2bac4aae3ed4dd7b811dd1a72ea4aa71001aa27839d641b07743c0cb5f68c51f8cd31d2c0762bec00dc6fcd25433ef1ab5b60001f346195ac02f37d60d4db8ffa6ef74cb1be3550047543a4a9ee9acf4d78697b0"; + // VAA Info: + // module name: 0x1 + // action: 2 + // chain: 21 + // data sources (chain, addr) pairs: [(1, 0xf346195ac02f37d60d4db8ffa6ef74cb1be3550047543a4a9ee9acf4d78697b0), (26, 0xa27839d641b07743c0cb5f68c51f8cd31d2c0762bec00dc6fcd25433ef1ab5b6), (26, 0xe101faedac5851e32b9b23b5f9411a8c2bac4aae3ed4dd7b811dd1a72ea4aa71)] + + const DEPLOYER: address = @0x1234; + const DEFAULT_BASE_UPDATE_FEE: u64 = 0; + const DEFAULT_COIN_TO_MINT: u64 = 0; + + #[test] + fun set_data_sources(){ + let (scenario, test_coins, clock) = setup_test(500, 1, x"63278d271099bfd491951b3e648f08b1c71631e4a53674ad43e8f9f98068c385", pyth_tests::data_sources_for_test_vaa(), vector[x"13947bd48b18e53fdaeee77f3473391ac727c638"], DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + test_scenario::next_tx(&mut scenario, DEPLOYER); + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + let verified_vaa = wormhole::vaa::parse_and_verify(&worm_state, SET_DATA_SOURCES_VAA, &clock); + + let receipt = pyth::governance::verify_vaa(&pyth_state, verified_vaa); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::governance::execute_governance_instruction(&mut pyth_state, receipt); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + // assert data sources are set correctly + + assert!(state::is_valid_data_source(&pyth_state, data_source::new(1, external_address::new(bytes32::from_bytes(x"f346195ac02f37d60d4db8ffa6ef74cb1be3550047543a4a9ee9acf4d78697b0")))), 0); + assert!(state::is_valid_data_source(&pyth_state, data_source::new(26, external_address::new(bytes32::from_bytes(x"a27839d641b07743c0cb5f68c51f8cd31d2c0762bec00dc6fcd25433ef1ab5b6")))), 0); + assert!(state::is_valid_data_source(&pyth_state, data_source::new(26, external_address::new(bytes32::from_bytes(x"e101faedac5851e32b9b23b5f9411a8c2bac4aae3ed4dd7b811dd1a72ea4aa71")))), 0); + + // clean up + coin::burn_for_testing(test_coins); + pyth_tests::cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } +} diff --git a/target_chains/iota/contracts/sources/governance/set_fee_recipient.move b/target_chains/iota/contracts/sources/governance/set_fee_recipient.move new file mode 100644 index 0000000000..602b5e1324 --- /dev/null +++ b/target_chains/iota/contracts/sources/governance/set_fee_recipient.move @@ -0,0 +1,32 @@ +/// The previous version of the contract sent the fees to a recipient address but this state is not used anymore +/// This module is kept for backward compatibility +module pyth::set_fee_recipient { + use wormhole::cursor; + use wormhole::external_address::{Self}; + + use pyth::state::{Self, State, LatestOnly}; + + friend pyth::governance; + + struct PythFeeRecipient { + recipient: address + } + + public(friend) fun execute(latest_only: &LatestOnly, state: &mut State, payload: vector) { + let PythFeeRecipient { recipient } = from_byte_vec(payload); + state::set_fee_recipient(latest_only, state, recipient); + } + + fun from_byte_vec(payload: vector): PythFeeRecipient { + let cur = cursor::new(payload); + + // Recipient must be non-zero address. + let recipient = external_address::take_nonzero(&mut cur); + + cursor::destroy_empty(cur); + + PythFeeRecipient { + recipient: external_address::to_address(recipient) + } + } +} diff --git a/target_chains/iota/contracts/sources/governance/set_governance_data_source.move b/target_chains/iota/contracts/sources/governance/set_governance_data_source.move new file mode 100644 index 0000000000..682a1a7182 --- /dev/null +++ b/target_chains/iota/contracts/sources/governance/set_governance_data_source.move @@ -0,0 +1,36 @@ +module pyth::set_governance_data_source { + use pyth::deserialize; + use pyth::data_source; + use pyth::state::{Self, State, LatestOnly}; + + use wormhole::cursor; + use wormhole::external_address::{Self, ExternalAddress}; + use wormhole::bytes32::{Self}; + + friend pyth::governance; + + struct GovernanceDataSource { + emitter_chain_id: u64, + emitter_address: ExternalAddress, + initial_sequence: u64, + } + + public(friend) fun execute(latest_only: &LatestOnly, pyth_state: &mut State, payload: vector) { + let GovernanceDataSource { emitter_chain_id, emitter_address, initial_sequence: initial_sequence } = from_byte_vec(payload); + state::set_governance_data_source(latest_only, pyth_state, data_source::new(emitter_chain_id, emitter_address)); + state::set_last_executed_governance_sequence(latest_only, pyth_state, initial_sequence); + } + + fun from_byte_vec(bytes: vector): GovernanceDataSource { + let cursor = cursor::new(bytes); + let emitter_chain_id = deserialize::deserialize_u16(&mut cursor); + let emitter_address = external_address::new(bytes32::from_bytes(deserialize::deserialize_vector(&mut cursor, 32))); + let initial_sequence = deserialize::deserialize_u64(&mut cursor); + cursor::destroy_empty(cursor); + GovernanceDataSource { + emitter_chain_id: (emitter_chain_id as u64), + emitter_address, + initial_sequence + } + } +} diff --git a/target_chains/iota/contracts/sources/governance/set_stale_price_threshold.move b/target_chains/iota/contracts/sources/governance/set_stale_price_threshold.move new file mode 100644 index 0000000000..69efd66312 --- /dev/null +++ b/target_chains/iota/contracts/sources/governance/set_stale_price_threshold.move @@ -0,0 +1,72 @@ +module pyth::set_stale_price_threshold { + use wormhole::cursor; + + use pyth::deserialize; + use pyth::state::{Self, State, LatestOnly}; + + friend pyth::governance; + + struct StalePriceThreshold { + threshold: u64, + } + + public(friend) fun execute(latest_only: &LatestOnly, state: &mut State, payload: vector) { + let StalePriceThreshold { threshold } = from_byte_vec(payload); + state::set_stale_price_threshold_secs(latest_only, state, threshold); + } + + fun from_byte_vec(bytes: vector): StalePriceThreshold { + let cursor = cursor::new(bytes); + let threshold = deserialize::deserialize_u64(&mut cursor); + cursor::destroy_empty(cursor); + StalePriceThreshold { + threshold + } + } +} + +#[test_only] +module pyth::set_stale_price_threshold_test { + use iota::test_scenario::{Self}; + use iota::coin::Self; + + use pyth::pyth_tests::{Self, setup_test, take_wormhole_and_pyth_states}; + use pyth::state::Self; + + const SET_STALE_PRICE_THRESHOLD_VAA: vector = x"010000000001000393eabdb4983e91e0fcfe7e6b2fc5c8fca2847fde52fd2f51a9b26b12298da13af09c271ce7723af8e0b1f52afa02b56f0b64764739b1b05e2f2c5cec80567c000000000000000000000163278d271099bfd491951b3e648f08b1c71631e4a53674ad43e8f9f98068c3850000000000000001015054474d0104001500000000000f4020"; + // VAA Info: + // module name: 0x1 + // action: 4 + // chain: 21 + // stale price threshold: 999456 + + const DEPLOYER: address = @0x1234; + const DEFAULT_BASE_UPDATE_FEE: u64 = 0; + const DEFAULT_COIN_TO_MINT: u64 = 0; + + #[test] + fun set_stale_price_threshold(){ + + let (scenario, test_coins, clock) = setup_test(500, 1, x"63278d271099bfd491951b3e648f08b1c71631e4a53674ad43e8f9f98068c385", pyth_tests::data_sources_for_test_vaa(), vector[x"13947bd48b18e53fdaeee77f3473391ac727c638"], DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + test_scenario::next_tx(&mut scenario, DEPLOYER); + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + let verified_vaa = wormhole::vaa::parse_and_verify(&worm_state, SET_STALE_PRICE_THRESHOLD_VAA, &clock); + + let receipt = pyth::governance::verify_vaa(&pyth_state, verified_vaa); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::governance::execute_governance_instruction(&mut pyth_state, receipt); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + // assert stale price threshold is set correctly + assert!(state::get_stale_price_threshold_secs(&pyth_state)==999456, 0); + + // clean up + coin::burn_for_testing(test_coins); + pyth_tests::cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } +} diff --git a/target_chains/iota/contracts/sources/governance/set_update_fee.move b/target_chains/iota/contracts/sources/governance/set_update_fee.move new file mode 100644 index 0000000000..c5c7fa07f7 --- /dev/null +++ b/target_chains/iota/contracts/sources/governance/set_update_fee.move @@ -0,0 +1,85 @@ +module pyth::set_update_fee { + use std::u64; + + use wormhole::cursor; + + use pyth::deserialize; + use pyth::state::{Self, State, LatestOnly}; + + friend pyth::governance; + + const E_EXPONENT_DOES_NOT_FIT_IN_U8: u64 = 0; + + struct UpdateFee { + mantissa: u64, + exponent: u64, + } + + public(friend) fun execute(latest_only: &LatestOnly, pyth_state: &mut State, payload: vector) { + let UpdateFee { mantissa, exponent } = from_byte_vec(payload); + assert!(exponent <= 255, E_EXPONENT_DOES_NOT_FIT_IN_U8); + let fee = apply_exponent(mantissa, (exponent as u8)); + state::set_base_update_fee(latest_only, pyth_state, fee); + } + + fun from_byte_vec(bytes: vector): UpdateFee { + let cursor = cursor::new(bytes); + let mantissa = deserialize::deserialize_u64(&mut cursor); + let exponent = deserialize::deserialize_u64(&mut cursor); + cursor::destroy_empty(cursor); + UpdateFee { + mantissa, + exponent, + } + } + + fun apply_exponent(mantissa: u64, exponent: u8): u64 { + mantissa * u64::pow(10, exponent) + } +} + +#[test_only] +module pyth::set_update_fee_tests { + use iota::test_scenario::{Self}; + use iota::coin::Self; + + use pyth::pyth_tests::{Self, setup_test, take_wormhole_and_pyth_states}; + use pyth::state::Self; + + const SET_FEE_VAA: vector = x"01000000000100189d01616814b185b5a26bde6123d48e0d44dd490bbb3bde5d12076247b2180068a8261165777076ae532b7b0739aaee6411c8ba0695d20d4fa548227ce15d8d010000000000000000000163278d271099bfd491951b3e648f08b1c71631e4a53674ad43e8f9f98068c3850000000000000001015054474d0103001500000000000000050000000000000005"; + // VAA Info: + // module name: 0x1 + // action: 3 + // chain: 21 + // new fee: 5, new exponent: 5 + + const DEPLOYER: address = @0x1234; + const DEFAULT_BASE_UPDATE_FEE: u64 = 0; + const DEFAULT_COIN_TO_MINT: u64 = 0; + + #[test] + fun test_set_update_fee(){ + + let (scenario, test_coins, clock) = setup_test(500, 1, x"63278d271099bfd491951b3e648f08b1c71631e4a53674ad43e8f9f98068c385", pyth_tests::data_sources_for_test_vaa(), vector[x"13947bd48b18e53fdaeee77f3473391ac727c638"], DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + test_scenario::next_tx(&mut scenario, DEPLOYER); + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + let verified_vaa = wormhole::vaa::parse_and_verify(&worm_state, SET_FEE_VAA, &clock); + + let receipt = pyth::governance::verify_vaa(&pyth_state, verified_vaa); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::governance::execute_governance_instruction(&mut pyth_state, receipt); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + // assert fee is set correctly + assert!(state::get_base_update_fee(&pyth_state)==500000, 0); + + // clean up + coin::burn_for_testing(test_coins); + pyth_tests::cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } +} diff --git a/target_chains/iota/contracts/sources/hot_potato_vector.move b/target_chains/iota/contracts/sources/hot_potato_vector.move new file mode 100644 index 0000000000..a733a6ce51 --- /dev/null +++ b/target_chains/iota/contracts/sources/hot_potato_vector.move @@ -0,0 +1,66 @@ +/// This class represents a vector of objects wrapped +/// inside of a hot potato struct. +module pyth::hot_potato_vector { + use std::vector; + + friend pyth::pyth; + #[test_only] + friend pyth::pyth_tests; + + // A hot potato containing a vector of elements + struct HotPotatoVector { + contents: vector + } + + // A public destroy function. + public fun destroy(hot_potato_vector: HotPotatoVector) { + let HotPotatoVector { contents: _ } = hot_potato_vector; + } + + // Only certain on-chain functions are allowed to create a new hot potato vector. + public(friend) fun new(vec: vector): HotPotatoVector { + HotPotatoVector { + contents: vec + } + } + + public fun length(potato: &HotPotatoVector): u64 { + vector::length(&potato.contents) + } + + public fun is_empty(potato: &HotPotatoVector): bool { + vector::is_empty(&potato.contents) + } + + public(friend) fun borrow(potato: &HotPotatoVector, i: u64): &T { + vector::borrow(&potato.contents, i) + } + + public(friend) fun pop_back(hot_potato_vector: HotPotatoVector): (T, HotPotatoVector) { + let elem = vector::pop_back(&mut hot_potato_vector.contents); + return (elem, hot_potato_vector) + } + + #[test_only] + struct A has copy, drop { + a: u64 + } + + #[test] + fun test_hot_potato_vector() { + let vec_of_a = vector::empty(); + vector::push_back(&mut vec_of_a, A { a: 5 }); + vector::push_back(&mut vec_of_a, A { a: 11 }); + vector::push_back(&mut vec_of_a, A { a: 23 }); + + let hot_potato = new(vec_of_a); + let (b, hot_potato) = pop_back(hot_potato); + assert!(b.a == 23, 0); + (b, hot_potato) = pop_back(hot_potato); + assert!(b.a == 11, 0); + let (b, hot_potato) = pop_back(hot_potato); + assert!(b.a == 5, 0); + + destroy(hot_potato); + } +} diff --git a/target_chains/iota/contracts/sources/i64.move b/target_chains/iota/contracts/sources/i64.move new file mode 100644 index 0000000000..889e7ba752 --- /dev/null +++ b/target_chains/iota/contracts/sources/i64.move @@ -0,0 +1,140 @@ +module pyth::i64 { + //use pyth::error; + + const MAX_POSITIVE_MAGNITUDE: u64 = (1 << 63) - 1; + const MAX_NEGATIVE_MAGNITUDE: u64 = (1 << 63); + + /// As Move does not support negative numbers natively, we use our own internal + /// representation. + /// + /// To consume these values, first call `get_is_negative()` to determine if the I64 + /// represents a negative or positive value. Then call `get_magnitude_if_positive()` or + /// `get_magnitude_if_negative()` to get the magnitude of the number in unsigned u64 format. + /// This API forces consumers to handle positive and negative numbers safely. + struct I64 has copy, drop, store { + negative: bool, + magnitude: u64, + } + + public fun new(magnitude: u64, negative: bool): I64 { + let max_magnitude = MAX_POSITIVE_MAGNITUDE; + if (negative) { + max_magnitude = MAX_NEGATIVE_MAGNITUDE; + }; + assert!(magnitude <= max_magnitude, 0); //error::magnitude_too_large() + + + // Ensure we have a single zero representation: (0, false). + // (0, true) is invalid. + if (magnitude == 0) { + negative = false; + }; + + I64 { + magnitude, + negative, + } + } + + public fun get_is_negative(i: &I64): bool { + i.negative + } + + public fun get_magnitude_if_positive(in: &I64): u64 { + assert!(!in.negative, 0); // error::negative_value() + in.magnitude + } + + public fun get_magnitude_if_negative(in: &I64): u64 { + assert!(in.negative, 0); //error::positive_value() + in.magnitude + } + + public fun from_u64(from: u64): I64 { + // Use the MSB to determine whether the number is negative or not. + let negative = (from >> 63) == 1; + let magnitude = parse_magnitude(from, negative); + + new(magnitude, negative) + } + + fun parse_magnitude(from: u64, negative: bool): u64 { + // If positive, then return the input verbatamin + if (!negative) { + return from + }; + + // Otherwise convert from two's complement by inverting and adding 1 + let inverted = from ^ 0xFFFFFFFFFFFFFFFF; + inverted + 1 + } + + #[test] + fun test_max_positive_magnitude() { + new(0x7FFFFFFFFFFFFFFF, false); + assert!(&new(1<<63 - 1, false) == &from_u64(1<<63 - 1), 1); + } + + #[test] + #[expected_failure] + fun test_magnitude_too_large_positive() { + new(0x8000000000000000, false); + } + + #[test] + fun test_max_negative_magnitude() { + new(0x8000000000000000, true); + assert!(&new(1<<63, true) == &from_u64(1<<63), 1); + } + + #[test] + #[expected_failure] + fun test_magnitude_too_large_negative() { + new(0x8000000000000001, true); + } + + #[test] + fun test_from_u64_positive() { + assert!(from_u64(0x64673) == new(0x64673, false), 1); + } + + #[test] + fun test_from_u64_negative() { + assert!(from_u64(0xFFFFFFFFFFFEDC73) == new(0x1238D, true), 1); + } + + #[test] + fun test_get_is_negative() { + assert!(get_is_negative(&new(234, true)) == true, 1); + assert!(get_is_negative(&new(767, false)) == false, 1); + } + + #[test] + fun test_get_magnitude_if_positive_positive() { + assert!(get_magnitude_if_positive(&new(7686, false)) == 7686, 1); + } + + #[test] + #[expected_failure] + fun test_get_magnitude_if_positive_negative() { + assert!(get_magnitude_if_positive(&new(7686, true)) == 7686, 1); + } + + #[test] + fun test_get_magnitude_if_negative_negative() { + assert!(get_magnitude_if_negative(&new(7686, true)) == 7686, 1); + } + + #[test] + #[expected_failure] + fun test_get_magnitude_if_negative_positive() { + assert!(get_magnitude_if_negative(&new(7686, false)) == 7686, 1); + } + + #[test] + fun test_single_zero_representation() { + assert!(&new(0, true) == &new(0, false), 1); + assert!(&new(0, true) == &from_u64(0), 1); + assert!(&new(0, false) == &from_u64(0), 1); + } +} diff --git a/target_chains/iota/contracts/sources/merkle_tree.move b/target_chains/iota/contracts/sources/merkle_tree.move new file mode 100644 index 0000000000..eb96cde668 --- /dev/null +++ b/target_chains/iota/contracts/sources/merkle_tree.move @@ -0,0 +1,397 @@ +// Implementation of a Merkle tree in Move. Supports constructing a new tree +// with a given depth, as well as proving that a leaf node belongs to the tree. +module pyth::merkle_tree { + use std::vector::{Self}; + use iota::hash::{keccak256}; + use wormhole::bytes20::{Self, Bytes20, data}; + use wormhole::cursor::Cursor; + use pyth::deserialize::{Self}; + + #[test_only] + use wormhole::cursor::{Self}; + + const MERKLE_LEAF_PREFIX: u8 = 0; + const MERKLE_NODE_PREFIX: u8 = 1; + const MERKLE_EMPTY_LEAF_PREFIX: u8 = 2; + + const E_DEPTH_NOT_LARGE_ENOUGH_FOR_MESSAGES: u64 = 1212121; + + // take keccak256 of input data, then return 20 leftmost bytes of result + fun hash(bytes: &vector): Bytes20 { + let hashed_bytes = keccak256(bytes); + let hash_prefix = vector::empty(); + let i = 0; + while (i < 20) { + vector::push_back(&mut hash_prefix, *vector::borrow(&hashed_bytes, i)); + i = i + 1; + }; + bytes20::new(hash_prefix) + } + + fun empty_leaf_hash(): Bytes20 { + let v = vector[MERKLE_EMPTY_LEAF_PREFIX]; + hash(&v) + } + + fun leaf_hash(data: &vector): Bytes20 { + let v = vector[MERKLE_LEAF_PREFIX]; + let i = 0; + while (i < vector::length(data)) { + vector::push_back(&mut v, *vector::borrow(data, i)); + i = i + 1; + }; + hash(&v) + } + + fun node_hash( + childA: Bytes20, + childB: Bytes20 + ): Bytes20 { + if (greater_than(&childA, &childB)) { + (childA, childB) = (childB, childA); + }; + // append data_B to data_A + let data_A = bytes20::data(&childA); + let data_B = bytes20::data(&childB); + + // create a vector containing MERKLE_NODE_PREFIX + data_A + data_B + let v = vector[MERKLE_NODE_PREFIX]; + let i = 0; + while (i < 20) { + vector::push_back(&mut v, *vector::borrow(&data_A, i)); + i = i + 1; + }; + let i = 0; + while (i < 20) { + vector::push_back(&mut v, *vector::borrow(&data_B, i)); + i = i + 1; + }; + hash(&v) + } + + // greater_than returns whether a is strictly greater than b + // note that data(&a) and data(&b) are both vectors of length 20 + fun greater_than(a: &Bytes20, b: &Bytes20): bool { + // aa and bb both have length 20 + let a_vector = data(a); + let b_vector = data(b); + let i = 0; + while (i < 20) { + let a_value = *vector::borrow(&a_vector, i); + let b_value = *vector::borrow(&b_vector, i); + if (a_value > b_value) { + return true + } else if (b_value > a_value) { + return false + }; + i = i + 1; + }; + false + } + + // The Iota Move stdlb insert function shifts v[i] and subsequent elements to the right. + // We don't want this behavior, so we define our own set_element function that instead replaces the ith element. + // Reference: https://github.com/MystenLabs/iota/blob/main/crates/iota-framework/packages/move-stdlib/sources/vector.move + fun set_element(a: &mut vector, value: T, index: u64){ + vector::push_back(a, value); // push value to end + vector::swap_remove(a, index); // swap value to correct position and pop last value + } + + // is_proof_valid returns whether a merkle proof is valid + public fun is_proof_valid( + encoded_proof: &mut Cursor, + root: Bytes20, + leaf_data: vector, + ): bool { + let current_digest: Bytes20 = leaf_hash(&leaf_data); + let proofSize: u8 = deserialize::deserialize_u8(encoded_proof); + while (proofSize > 0){ + let sibling_digest: Bytes20 = bytes20::new( + deserialize::deserialize_vector(encoded_proof, 20) + ); + + current_digest = node_hash( + current_digest, + sibling_digest + ); + proofSize = proofSize - 1; + }; + bytes20::data(¤t_digest) == bytes20::data(&root) + } + + // construct_proofs constructs a merkle tree and returns the root of the tree as + // a Bytes20 as well as the vector of encoded proofs + public fun construct_proofs( + messages: &vector>, + depth: u8 + ) : (Bytes20, vector) { + + if ( 1 << depth < vector::length(messages)) { + abort E_DEPTH_NOT_LARGE_ENOUGH_FOR_MESSAGES + }; + + // empty tree + // The tree is structured as follows: + // 1 + // 2 3 + // 4 5 6 7 + // ... + // In this structure the parent of node x is x//2 and the children + // of node x are x*2 and x*2 + 1. Also, the sibling of the node x + // is x^1. The root is at index 1 and index 0 is not used. + let tree = vector::empty(); + + // empty leaf hash + let cachedEmptyLeafHash: Bytes20 = empty_leaf_hash(); + + // Instantiate tree to be a full binary tree with the appropriate depth. + // Add an entry at the end for swapping + let i: u64 = 0; + while (i < (1 << (depth+1)) + 1){ + vector::push_back(&mut tree, cachedEmptyLeafHash); + i = i + 1; + }; + + // Fill in bottom row with leaf hashes + let j: u64 = 0; + while (j < vector::length(messages)){ + set_element(&mut tree, leaf_hash(vector::borrow(messages, j)), (1 << depth) + j); + j = j + 1; + }; + + // Filling the node hashes from bottom to top + let k: u8 = depth; + while (k>0){ + let level: u8 = k-1; + let levelNumNodes = 1 << level; + let i: u64 = 0; + while (i < levelNumNodes ){ + let id = (1 << level) + i; + let node_hash = node_hash(*vector::borrow(&tree, id * 2), *vector::borrow(&tree, id * 2 + 1)); + set_element(&mut tree, node_hash, id); + i = i + 1; + }; + k = k - 1; + }; + + let root = *vector::borrow(&tree, 1); + + // construct proofs and create encoded proofs vector + let proofs = vector::empty(); + let i: u64 = 0; + while (i < vector::length(messages)){ + let cur_proof = vector::empty(); + vector::push_back(&mut cur_proof, depth); + let idx = (1 << depth) + i; + while (idx > 1) { + vector::append(&mut cur_proof, bytes20::data(vector::borrow(&tree, idx ^ 1))); + + // Jump to parent + idx = idx / 2; + }; + vector::append(&mut proofs, cur_proof); + i = i + 1; + }; + + (root, proofs) + } + + #[test] + fun testGreaterThan(){ + // test 1 + let x = bytes20::new(x"0000000000000000000000000000000000001000"); + let y = bytes20::new(x"0000000000000000000000000000000000000001"); + let res = greater_than(&x, &y); + assert!(res==true, 0); + res = greater_than(&y, &x); + assert!(res==false, 0); + + // test 2 + x = bytes20::new(x"1100000000000000000000000000000000001000"); + y = bytes20::new(x"1100000000000000000000000000000000000001"); + res = greater_than(&x, &y); + assert!(res==true, 0); + + // equality case + x = bytes20::new(x"1100000000000000000000000000000000001001"); + y = bytes20::new(x"1100000000000000000000000000000000001001"); + res = greater_than(&x, &y); + assert!(res==false, 0); + } + + #[test] + fun test_hash_leaf() { + let data: vector = x"00640000000000000000000000000000000000000000000000000000000000000000000000000000640000000000000064000000640000000000000064000000000000006400000000000000640000000000000064"; + let hash = leaf_hash(&data); + let expected = bytes20::new(x"afc6a8ac466430f35895055f8a4c951785dad5ce"); + assert!(hash == expected, 1); + } + + #[test] + fun test_hash_node() { + let h1 = bytes20::new(x"05c51b04b820c0f704e3fdd2e4fc1e70aff26dff"); + let h2 = bytes20::new(x"1e108841c8d21c7a5c4860c8c3499c918ea9e0ac"); + let hash = node_hash(h1, h2); + let expected = bytes20::new(x"2d0e4fde68184c7ce8af426a0865bd41ef84dfa4"); + assert!(hash == expected, 1); + } + + #[test] + fun testMerkleTreeDepth1(){ + let messages = vector::empty>(); + vector::push_back(&mut messages, x"1234"); + + let (root, proofs) = construct_proofs(&messages, 1); + + let proofs_cursor = cursor::new(proofs); + let valid = is_proof_valid(&mut proofs_cursor, root, x"1234"); + assert!(valid==true, 0); + + // destroy cursor + cursor::take_rest(proofs_cursor); + } + + #[test] + fun testMerkleTreeDepth2(){ + let messages = vector::empty>(); + vector::push_back(&mut messages, x"1234"); + vector::push_back(&mut messages, x"4321"); + vector::push_back(&mut messages, x"11"); + vector::push_back(&mut messages, x"22"); + + let (root, proofs) = construct_proofs(&messages, 2); + + let proofs_cursor = cursor::new(proofs); + assert!(is_proof_valid(&mut proofs_cursor, root, x"1234")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"4321")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"11")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"22")==true, 0); + + // destroy cursor + cursor::take_rest(proofs_cursor); + } + + #[test] + fun test_merkle_tree_depth_3(){ + let messages = vector::empty>(); + vector::push_back(&mut messages, x"00"); + vector::push_back(&mut messages, x"4321"); + vector::push_back(&mut messages, x"444444"); + vector::push_back(&mut messages, x"22222222"); + vector::push_back(&mut messages, x"22"); + vector::push_back(&mut messages, x"11"); + vector::push_back(&mut messages, x"100000"); + vector::push_back(&mut messages, x"eeeeee"); + + let (root, proofs) = construct_proofs(&messages, 3); + + let proofs_cursor = cursor::new(proofs); + assert!(is_proof_valid(&mut proofs_cursor, root, x"00")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"4321")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"444444")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"22222222")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"22")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"11")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"100000")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"eeeeee")==true, 0); + + // destroy cursor + cursor::take_rest(proofs_cursor); + } + + #[test] + fun test_merkle_tree_depth_1_invalid_proofs(){ + let messages = vector::empty>(); + vector::push_back(&mut messages, x"1234"); + + let (root, proofs) = construct_proofs(&messages, 1); + + let proofs_cursor = cursor::new(proofs); + + // use wrong leaf data (it is not included in the tree) + let valid = is_proof_valid(&mut proofs_cursor, root, x"432222"); + assert!(valid==false, 0); + + // destroy cursor + cursor::take_rest(proofs_cursor); + } + + #[test] + fun test_merkle_tree_depth_2_invalid_proofs(){ + let messages = vector::empty>(); + vector::push_back(&mut messages, x"1234"); + vector::push_back(&mut messages, x"4321"); + vector::push_back(&mut messages, x"11"); + vector::push_back(&mut messages, x"22"); + + let (root, proofs) = construct_proofs(&messages, 2); + + let proofs_cursor = cursor::new(proofs); + // proof fails because we used the proof of x"1234" to try to prove that x"4321" is in the tree + assert!(is_proof_valid(&mut proofs_cursor, root, x"4321")==false, 0); + // proof succeeds + assert!(is_proof_valid(&mut proofs_cursor, root, x"4321")==true, 0); + // proof fails because we used the proof of x"11" to try to prove that x"22" is in the tree + assert!(is_proof_valid(&mut proofs_cursor, root, x"22")==false, 0); + // proof succeeds + assert!(is_proof_valid(&mut proofs_cursor, root, x"22")==true, 0); + + // destroy cursor + cursor::take_rest(proofs_cursor); + } + + #[test] + fun test_merkle_tree_depth_3_invalid_proofs(){ + let messages = vector::empty>(); + vector::push_back(&mut messages, x"00"); + vector::push_back(&mut messages, x"4321"); + vector::push_back(&mut messages, x"444444"); + vector::push_back(&mut messages, x"22222222"); + vector::push_back(&mut messages, x"22"); + vector::push_back(&mut messages, x"11"); + vector::push_back(&mut messages, x"100000"); + vector::push_back(&mut messages, x"eeeeee"); + + let (root, proofs) = construct_proofs(&messages, 3); + + let proofs_cursor = cursor::new(proofs); + + // test various proof failure cases (because of mismatch between proof and leaf data) + assert!(is_proof_valid(&mut proofs_cursor, root, x"00")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"22")==false, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"22222222")==false, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"22222222")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"22")==true, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"eeeeee")==false, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"4321")==false, 0); + assert!(is_proof_valid(&mut proofs_cursor, root, x"eeeeee")==true, 0); + + // destroy cursor + cursor::take_rest(proofs_cursor); + } + + #[test] + #[expected_failure(abort_code = pyth::merkle_tree::E_DEPTH_NOT_LARGE_ENOUGH_FOR_MESSAGES)] + fun test_merkle_tree_depth_exceeded_1(){ + let messages = vector::empty>(); + vector::push_back(&mut messages, x"00"); + vector::push_back(&mut messages, x"4321"); + vector::push_back(&mut messages, x"444444"); + + construct_proofs(&messages, 1); //depth 1 + } + + #[test] + #[expected_failure(abort_code = pyth::merkle_tree::E_DEPTH_NOT_LARGE_ENOUGH_FOR_MESSAGES)] + fun test_merkle_tree_depth_exceeded_2(){ + let messages = vector::empty>(); + vector::push_back(&mut messages, x"00"); + vector::push_back(&mut messages, x"4321"); + vector::push_back(&mut messages, x"444444"); + vector::push_back(&mut messages, x"22222222"); + vector::push_back(&mut messages, x"22"); + + construct_proofs(&messages, 2); // depth 2 + } + +} diff --git a/target_chains/iota/contracts/sources/migrate.move b/target_chains/iota/contracts/sources/migrate.move new file mode 100644 index 0000000000..49d53017b3 --- /dev/null +++ b/target_chains/iota/contracts/sources/migrate.move @@ -0,0 +1,77 @@ +// SPDX-License-Identifier: Apache 2 + + +/// Note: this module is adapted from Wormhole's migrade.move module. +/// +/// This module implements a public method intended to be called after an +/// upgrade has been commited. The purpose is to add one-off migration logic +/// that would alter Pyth `State`. +/// +/// Included in migration is the ability to ensure that breaking changes for +/// any of Pyth's methods by enforcing the current build version as +/// their required minimum version. +module pyth::migrate { + use iota::object::{ID}; + + use pyth::state::{Self, State}; + use pyth::contract_upgrade::{Self}; + use pyth::governance::{WormholeVAAVerificationReceipt}; + + struct MigrateComplete has drop, copy { + package: ID + } + + public fun migrate( + pyth_state: &mut State, + receipt: WormholeVAAVerificationReceipt, + ) { + + // Perform standard migrate. + handle_migrate(pyth_state, receipt); + + //////////////////////////////////////////////////////////////////////// + // + // NOTE: Put any one-off migration logic here. + // + // Most upgrades likely won't need to do anything, in which case the + // rest of this function's body may be empty. Make sure to delete it + // after the migration has gone through successfully. + // + // WARNING: The migration does *not* proceed atomically with the + // upgrade (as they are done in separate transactions). + // If the nature of this migration absolutely requires the migration to + // happen before certain other functionality is available, then guard + // that functionality with the `assert!` from above. + // + //////////////////////////////////////////////////////////////////////// + + //////////////////////////////////////////////////////////////////////// + } + + fun handle_migrate( + pyth_state: &mut State, + receipt: WormholeVAAVerificationReceipt, + ) { + // See `version_control` module for hard-coded configuration. + state::migrate_version(pyth_state); + + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(pyth_state); + + let digest = contract_upgrade::take_upgrade_digest(receipt); + state::assert_authorized_digest( + &latest_only, + pyth_state, + digest + ); + + // Finally emit an event reflecting a successful migrate. + let package = state::current_package(&latest_only, pyth_state); + iota::event::emit(MigrateComplete { package }); + } + + #[test_only] + public fun set_up_migrate(pyth_state: &mut State) { + state::reverse_migrate__v__0_1_0(pyth_state); + } +} diff --git a/target_chains/iota/contracts/sources/price.move b/target_chains/iota/contracts/sources/price.move new file mode 100644 index 0000000000..ea92602b9e --- /dev/null +++ b/target_chains/iota/contracts/sources/price.move @@ -0,0 +1,46 @@ +module pyth::price { + use pyth::i64::I64; + + /// A price with a degree of uncertainty, represented as a price +- a confidence interval. + /// + /// The confidence interval roughly corresponds to the standard error of a normal distribution. + /// Both the price and confidence are stored in a fixed-point numeric representation, + /// `x * (10^expo)`, where `expo` is the exponent. + // + /// Please refer to the documentation at https://docs.pyth.network/documentation/pythnet-price-feeds/best-practices for how + /// to how this price safely. + struct Price has copy, drop, store { + price: I64, + /// Confidence interval around the price + conf: u64, + /// The exponent + expo: I64, + /// Unix timestamp of when this price was computed + timestamp: u64, + } + + public fun new(price: I64, conf: u64, expo: I64, timestamp: u64): Price { + Price { + price, + conf, + expo, + timestamp, + } + } + + public fun get_price(price: &Price): I64 { + price.price + } + + public fun get_conf(price: &Price): u64 { + price.conf + } + + public fun get_timestamp(price: &Price): u64 { + price.timestamp + } + + public fun get_expo(price: &Price): I64 { + price.expo + } +} diff --git a/target_chains/iota/contracts/sources/price_feed.move b/target_chains/iota/contracts/sources/price_feed.move new file mode 100644 index 0000000000..11a236f833 --- /dev/null +++ b/target_chains/iota/contracts/sources/price_feed.move @@ -0,0 +1,47 @@ +module pyth::price_feed { + use pyth::price_identifier::PriceIdentifier; + use pyth::price::Price; + + /// PriceFeed represents a current aggregate price for a particular product. + struct PriceFeed has copy, drop, store { + /// The price identifier + price_identifier: PriceIdentifier, + /// The current aggregate price + price: Price, + /// The current exponentially moving average aggregate price + ema_price: Price, + } + + public fun new( + price_identifier: PriceIdentifier, + price: Price, + ema_price: Price): PriceFeed { + PriceFeed { + price_identifier, + price, + ema_price, + } + } + + public fun from( + price_feed: &PriceFeed + ): PriceFeed { + PriceFeed { + price_identifier: price_feed.price_identifier, + price: price_feed.price, + ema_price: price_feed.ema_price, + } + } + + public fun get_price_identifier(price_feed: &PriceFeed): PriceIdentifier { + price_feed.price_identifier + } + + public fun get_price(price_feed: &PriceFeed): Price { + price_feed.price + } + + public fun get_ema_price(price_feed: &PriceFeed): Price { + price_feed.ema_price + } +} diff --git a/target_chains/iota/contracts/sources/price_identifier.move b/target_chains/iota/contracts/sources/price_identifier.move new file mode 100644 index 0000000000..dc05d22f29 --- /dev/null +++ b/target_chains/iota/contracts/sources/price_identifier.move @@ -0,0 +1,21 @@ +module pyth::price_identifier { + use std::vector; + + const IDENTIFIER_BYTES_LENGTH: u64 = 32; + const E_INCORRECT_IDENTIFIER_LENGTH: u64 = 0; + + struct PriceIdentifier has copy, drop, store { + bytes: vector, + } + + public fun from_byte_vec(bytes: vector): PriceIdentifier { + assert!(vector::length(&bytes) == IDENTIFIER_BYTES_LENGTH, E_INCORRECT_IDENTIFIER_LENGTH); + PriceIdentifier { + bytes + } + } + + public fun get_bytes(price_identifier: &PriceIdentifier): vector { + price_identifier.bytes + } +} diff --git a/target_chains/iota/contracts/sources/price_info.move b/target_chains/iota/contracts/sources/price_info.move new file mode 100644 index 0000000000..14b8acb5ee --- /dev/null +++ b/target_chains/iota/contracts/sources/price_info.move @@ -0,0 +1,223 @@ +module pyth::price_info { + use iota::object::{Self, UID, ID}; + use iota::tx_context::{TxContext}; + use iota::dynamic_object_field::{Self}; + use iota::table::{Self}; + use iota::coin::{Self, Coin}; + use iota::iota::IOTA; + + use pyth::price_feed::{Self, PriceFeed}; + use pyth::price_identifier::{PriceIdentifier}; + + const KEY: vector = b"price_info"; + const FEE_STORAGE_KEY: vector = b"fee_storage"; + const E_PRICE_INFO_REGISTRY_ALREADY_EXISTS: u64 = 0; + const E_PRICE_IDENTIFIER_ALREADY_REGISTERED: u64 = 1; + const E_PRICE_IDENTIFIER_NOT_REGISTERED: u64 = 2; + + friend pyth::pyth; + friend pyth::state; + + /// Iota object version of PriceInfo. + /// Has a key ability, is unique for each price identifier, and lives in global store. + struct PriceInfoObject has key, store { + id: UID, + price_info: PriceInfo + } + + /// Copyable and droppable. + struct PriceInfo has copy, drop, store { + attestation_time: u64, + arrival_time: u64, + price_feed: PriceFeed, + } + + /// Creates a table which maps a PriceIdentifier to the + /// UID (in bytes) of the corresponding Iota PriceInfoObject. + public(friend) fun new_price_info_registry(parent_id: &mut UID, ctx: &mut TxContext) { + assert!( + !dynamic_object_field::exists_(parent_id, KEY), + E_PRICE_INFO_REGISTRY_ALREADY_EXISTS + ); + dynamic_object_field::add( + parent_id, + KEY, + table::new(ctx) + ) + } + + public(friend) fun add(parent_id: &mut UID, price_identifier: PriceIdentifier, id: ID) { + assert!( + !contains(parent_id, price_identifier), + E_PRICE_IDENTIFIER_ALREADY_REGISTERED + ); + table::add( + dynamic_object_field::borrow_mut(parent_id, KEY), + price_identifier, + id + ) + } + + + /// Returns ID of price info object corresponding to price_identifier as a byte vector. + public fun get_id_bytes(parent_id: &UID, price_identifier: PriceIdentifier): vector { + assert!( + contains(parent_id, price_identifier), + E_PRICE_IDENTIFIER_NOT_REGISTERED + ); + object::id_to_bytes( + table::borrow( + dynamic_object_field::borrow(parent_id, KEY), + price_identifier + ) + ) + } + + /// Returns ID of price info object corresponding to price_identifier as an ID. + public fun get_id(parent_id: &UID, price_identifier: PriceIdentifier): ID { + assert!( + contains(parent_id, price_identifier), + E_PRICE_IDENTIFIER_NOT_REGISTERED + ); + object::id_from_bytes( + object::id_to_bytes( + table::borrow( + dynamic_object_field::borrow(parent_id, KEY), + price_identifier + ) + ) + ) + } + + public fun contains(parent_id: &UID, price_identifier: PriceIdentifier): bool { + let ref = dynamic_object_field::borrow(parent_id, KEY); + table::contains(ref, price_identifier) + } + + public fun get_balance(price_info_object: &PriceInfoObject): u64 { + if (!dynamic_object_field::exists_with_type, Coin>(&price_info_object.id, FEE_STORAGE_KEY)) { + return 0 + }; + let fee = dynamic_object_field::borrow, Coin>(&price_info_object.id, FEE_STORAGE_KEY); + coin::value(fee) + } + + public fun deposit_fee_coins(price_info_object: &mut PriceInfoObject, fee_coins: Coin) { + if (!dynamic_object_field::exists_with_type, Coin>(&price_info_object.id, FEE_STORAGE_KEY)) { + dynamic_object_field::add(&mut price_info_object.id, FEE_STORAGE_KEY, fee_coins); + } + else { + let current_fee = dynamic_object_field::borrow_mut, Coin>( + &mut price_info_object.id, + FEE_STORAGE_KEY + ); + coin::join(current_fee, fee_coins); + }; + } + + public(friend) fun new_price_info_object( + price_info: PriceInfo, + ctx: &mut TxContext + ): PriceInfoObject { + PriceInfoObject { + id: object::new(ctx), + price_info + } + } + + public fun new_price_info( + attestation_time: u64, + arrival_time: u64, + price_feed: PriceFeed, + ): PriceInfo { + PriceInfo { + attestation_time, + arrival_time, + price_feed, + } + } + + #[test] + public fun test_get_price_info_object_id_from_price_identifier(){ + use iota::object::{Self}; + use iota::test_scenario::{Self, ctx}; + use pyth::price_identifier::{Self}; + let scenario = test_scenario::begin(@pyth); + let uid = object::new(ctx(&mut scenario)); + + // Create a new price info object registry. + new_price_info_registry(&mut uid, ctx(&mut scenario)); + + // Register a price info object in the registry. + let price_identifier = price_identifier::from_byte_vec(x"ff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace"); + + // Create a new ID. + let id = object::id_from_bytes(x"19f253b07e88634bfd5a3a749f60bfdb83c9748910646803f06b60b76319e7ba"); + + add(&mut uid, price_identifier, id); + + let result = get_id_bytes(&uid, price_identifier); + + // Assert that ID matches original. + assert!(result==x"19f253b07e88634bfd5a3a749f60bfdb83c9748910646803f06b60b76319e7ba", 0); + + // Clean up. + object::delete(uid); + test_scenario::end(scenario); + } + + #[test_only] + public fun destroy(price_info: PriceInfoObject) { + let PriceInfoObject { + id, + price_info: _, + } = price_info; + object::delete(id); + } + + #[test_only] + public fun new_price_info_object_for_test( + price_info: PriceInfo, + ctx: &mut TxContext + ): PriceInfoObject { + PriceInfoObject { + id: object::new(ctx), + price_info + } + } + + public fun uid_to_inner(price_info: &PriceInfoObject): ID { + object::uid_to_inner(&price_info.id) + } + + public fun get_price_info_from_price_info_object(price_info: &PriceInfoObject): PriceInfo { + price_info.price_info + } + + public fun get_price_identifier(price_info: &PriceInfo): PriceIdentifier { + price_feed::get_price_identifier(&price_info.price_feed) + } + + public fun get_price_feed(price_info: &PriceInfo): &PriceFeed { + &price_info.price_feed + } + + public fun get_attestation_time(price_info: &PriceInfo): u64 { + price_info.attestation_time + } + + public fun get_arrival_time(price_info: &PriceInfo): u64 { + price_info.arrival_time + } + + public(friend) fun update_price_info_object( + price_info_object: &mut PriceInfoObject, + price_info: &PriceInfo + ) { + price_info_object.price_info = new_price_info( + price_info.attestation_time, + price_info.arrival_time, + price_info.price_feed + ); + } +} diff --git a/target_chains/iota/contracts/sources/price_status.move b/target_chains/iota/contracts/sources/price_status.move new file mode 100644 index 0000000000..031649ff7d --- /dev/null +++ b/target_chains/iota/contracts/sources/price_status.move @@ -0,0 +1,53 @@ +module pyth::price_status { + //use pyth::error; + + /// The price feed is not currently updating for an unknown reason. + const UNKNOWN: u64 = 0; + /// The price feed is updating as expected. + const TRADING: u64 = 1; + + /// PriceStatus represents the availability status of a price feed. + /// Prices should only be used if they have a status of trading. + struct PriceStatus has copy, drop, store { + status: u64, + } + + public fun from_u64(status: u64): PriceStatus { + assert!(status <= TRADING, 0); + PriceStatus { + status + } + } + + public fun get_status(price_status: &PriceStatus): u64 { + price_status.status + } + + public fun new_unknown(): PriceStatus { + PriceStatus { + status: UNKNOWN, + } + } + + public fun new_trading(): PriceStatus { + PriceStatus { + status: TRADING, + } + } + + #[test] + fun test_unknown_status() { + assert!(PriceStatus{ status: UNKNOWN } == from_u64(0), 1); + } + + #[test] + fun test_trading_status() { + assert!(PriceStatus{ status: TRADING } == from_u64(1), 1); + } + + #[test] + #[expected_failure] + fun test_invalid_price_status() { + from_u64(3); + } +} diff --git a/target_chains/iota/contracts/sources/pyth.move b/target_chains/iota/contracts/sources/pyth.move new file mode 100644 index 0000000000..710a94bb99 --- /dev/null +++ b/target_chains/iota/contracts/sources/pyth.move @@ -0,0 +1,1549 @@ +module pyth::pyth { + use std::vector; + use iota::tx_context::{TxContext}; + use iota::coin::{Self, Coin}; + use iota::iota::{IOTA}; + use iota::transfer::{Self}; + use iota::clock::{Self, Clock}; + use iota::package::{UpgradeCap}; + + use pyth::event::{Self as pyth_event}; + use pyth::data_source::{Self, DataSource}; + use pyth::state::{Self as state, State as PythState, LatestOnly}; + use pyth::price_info::{Self, PriceInfo, PriceInfoObject}; + use pyth::batch_price_attestation::{Self}; + use pyth::price_feed::{Self}; + use pyth::price::{Self, Price}; + use pyth::price_identifier::{PriceIdentifier}; + use pyth::setup::{Self, DeployerCap}; + use pyth::hot_potato_vector::{Self, HotPotatoVector}; + use pyth::accumulator::{Self}; + + use wormhole::external_address::{Self}; + use wormhole::vaa::{Self, VAA}; + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Self}; + + const E_DATA_SOURCE_EMITTER_ADDRESS_AND_CHAIN_IDS_DIFFERENT_LENGTHS: u64 = 0; + const E_INVALID_DATA_SOURCE: u64 = 1; + const E_INSUFFICIENT_FEE: u64 = 2; + const E_STALE_PRICE_UPDATE: u64 = 3; + const E_UPDATE_AND_PRICE_INFO_OBJECT_MISMATCH: u64 = 4; + const E_PRICE_UPDATE_NOT_FOUND_FOR_PRICE_INFO_OBJECT: u64 = 5; + + #[test_only] + friend pyth::pyth_tests; + + /// Init state and emit event corresponding to Pyth initialization. + public entry fun init_pyth( + deployer: DeployerCap, + upgrade_cap: UpgradeCap, + stale_price_threshold: u64, + governance_emitter_chain_id: u64, + governance_emitter_address: vector, + data_sources_emitter_chain_ids: vector, + data_sources_emitter_addresses: vector>, + update_fee: u64, + ctx: &mut TxContext + ) { + setup::init_and_share_state( + deployer, + upgrade_cap, + stale_price_threshold, + update_fee, + data_source::new( + governance_emitter_chain_id, + external_address::new((bytes32::from_bytes(governance_emitter_address))) + ), + parse_data_sources( + data_sources_emitter_chain_ids, + data_sources_emitter_addresses, + ), + ctx + ); + + // Emit Pyth initialization event. + pyth_event::emit_pyth_initialization_event(); + } + + fun parse_data_sources( + emitter_chain_ids: vector, + emitter_addresses: vector> + ): vector { + + assert!(vector::length(&emitter_chain_ids) == vector::length(&emitter_addresses), + E_DATA_SOURCE_EMITTER_ADDRESS_AND_CHAIN_IDS_DIFFERENT_LENGTHS); + + let sources = vector::empty(); + let i = 0; + while (i < vector::length(&emitter_chain_ids)) { + vector::push_back(&mut sources, data_source::new( + *vector::borrow(&emitter_chain_ids, i), + external_address::new(bytes32::from_bytes(*vector::borrow(&emitter_addresses, i))) + )); + + i = i + 1; + }; + sources + } + + /// Create and share new price feed objects if they don't already exist using accumulator message. + public fun create_price_feeds_using_accumulator( + pyth_state: &mut PythState, + accumulator_message: vector, + vaa: VAA, // the verified version of the vaa bytes encoded within the accumulator_message + clock: &Clock, + ctx: &mut TxContext + ){ + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(pyth_state); + + // Check that the VAA is from a valid data source (emitter) + assert!( + state::is_valid_data_source( + pyth_state, + data_source::new( + (vaa::emitter_chain(&vaa) as u64), + vaa::emitter_address(&vaa)) + ), + E_INVALID_DATA_SOURCE + ); + + // decode the price info updates from the VAA payload (first check if it is an accumulator or batch price update) + let accumulator_message_cursor = cursor::new(accumulator_message); + let price_infos = accumulator::parse_and_verify_accumulator_message(&mut accumulator_message_cursor, vaa::take_payload(vaa), clock); + + // Create and share new price info objects, if not already exists. + create_and_share_price_feeds_using_verified_price_infos(&latest_only, pyth_state, price_infos, ctx); + + // destroy rest of cursor + cursor::take_rest(accumulator_message_cursor); + } + + + /// Create and share new price feed objects if they don't already exist using batch price attestation. + /// The name of the function is kept as is to remain backward compatible + public fun create_price_feeds( + pyth_state: &mut PythState, + // These vaas have been verified and consumed, so we don't have to worry about + // doing replay protection for them. + verified_vaas: vector, + clock: &Clock, + ctx: &mut TxContext + ){ + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(pyth_state); + + while (!vector::is_empty(&verified_vaas)) { + let vaa = vector::pop_back(&mut verified_vaas); + + // Check that the VAA is from a valid data source (emitter) + assert!( + state::is_valid_data_source( + pyth_state, + data_source::new( + (vaa::emitter_chain(&vaa) as u64), + vaa::emitter_address(&vaa)) + ), + E_INVALID_DATA_SOURCE + ); + + // Deserialize the batch price attestation + let price_infos = batch_price_attestation::destroy(batch_price_attestation::deserialize(vaa::take_payload(vaa), clock)); + + // Create and share new price info objects, if not already exists. + create_and_share_price_feeds_using_verified_price_infos(&latest_only, pyth_state, price_infos, ctx); + }; + vector::destroy_empty(verified_vaas); + } + + #[allow(lint(share_owned))] + // create_and_share_price_feeds_using_verified_price_infos is a private function used by + // 1) create_price_feeds + // 2) create_price_feeds_using_accumulator + // to create new price feeds for symbols. + fun create_and_share_price_feeds_using_verified_price_infos(latest_only: &LatestOnly, pyth_state: &mut PythState, price_infos: vector, ctx: &mut TxContext){ + while (!vector::is_empty(&price_infos)){ + let cur_price_info = vector::pop_back(&mut price_infos); + + // Only create new Iota PriceInfoObject if not already + // registered with the Pyth State object. + if (!state::price_feed_object_exists( + pyth_state, + price_feed::get_price_identifier( + price_info::get_price_feed(&cur_price_info) + ) + ) + ){ + // Create and share newly created Iota PriceInfoObject containing a price feed, + // and then register a copy of its ID with State. + let new_price_info_object = price_info::new_price_info_object(cur_price_info, ctx); + let price_identifier = price_info::get_price_identifier(&cur_price_info); + let id = price_info::uid_to_inner(&new_price_info_object); + + state::register_price_info_object(latest_only, pyth_state, price_identifier, id); + + transfer::public_share_object(new_price_info_object); + } + } + } + + + // verified_vaa is the verified version of the VAA encoded within the accumulator_message + public fun create_authenticated_price_infos_using_accumulator( + pyth_state: &PythState, + accumulator_message: vector, + verified_vaa: VAA, + clock: &Clock, + ): HotPotatoVector { + state::assert_latest_only(pyth_state); + + // verify that the VAA originates from a valid data source + assert!( + state::is_valid_data_source( + pyth_state, + data_source::new( + (vaa::emitter_chain(&verified_vaa) as u64), + vaa::emitter_address(&verified_vaa)) + ), + E_INVALID_DATA_SOURCE + ); + + // decode the price info updates from the VAA payload (first check if it is an accumulator or batch price update) + let accumulator_message_cursor = cursor::new(accumulator_message); + let price_infos = accumulator::parse_and_verify_accumulator_message(&mut accumulator_message_cursor, vaa::take_payload(verified_vaa), clock); + + // check that accumulator message has been fully consumed + cursor::destroy_empty(accumulator_message_cursor); + hot_potato_vector::new(price_infos) + } + + /// Creates authenticated price infos using batch price attestation + /// Name is kept as is to remain backward compatible + public fun create_price_infos_hot_potato( + pyth_state: &PythState, + verified_vaas: vector, + clock: &Clock + ): HotPotatoVector { + state::assert_latest_only(pyth_state); + + let price_updates = vector::empty(); + while (vector::length(&verified_vaas) != 0){ + let cur_vaa = vector::pop_back(&mut verified_vaas); + + assert!( + state::is_valid_data_source( + pyth_state, + data_source::new( + (vaa::emitter_chain(&cur_vaa) as u64), + vaa::emitter_address(&cur_vaa)) + ), + E_INVALID_DATA_SOURCE + ); + let price_infos = batch_price_attestation::destroy(batch_price_attestation::deserialize(vaa::take_payload(cur_vaa), clock)); + while (vector::length(&price_infos) !=0 ){ + let cur_price_info = vector::pop_back(&mut price_infos); + vector::push_back(&mut price_updates, cur_price_info); + } + }; + vector::destroy_empty(verified_vaas); + return hot_potato_vector::new(price_updates) + } + + /// Update a singular Pyth PriceInfoObject (containing a price feed) with the + /// price data in the authenticated price infos vector (a vector of PriceInfo objects). + /// + /// For more information on the end-to-end process for updating a price feed, please see the README. + /// + /// The given fee must contain a sufficient number of coins to pay the update fee for the given vaas. + /// The update fee amount can be queried by calling get_update_fee(&vaas). + /// + /// Please read more information about the update fee here: https://docs.pyth.network/documentation/pythnet-price-feeds/on-demand#fees + public fun update_single_price_feed( + pyth_state: &PythState, + price_updates: HotPotatoVector, + price_info_object: &mut PriceInfoObject, + fee: Coin, + clock: &Clock + ): HotPotatoVector { + let latest_only = state::assert_latest_only(pyth_state); + + // On Iota, users get to choose which price feeds to update. They specify a single price feed to + // update at a time. We therefore charge the base fee for each such individual update. + // This is a departure from Eth, where users don't get to necessarily choose. + assert!(state::get_base_update_fee(pyth_state) <= coin::value(&fee), E_INSUFFICIENT_FEE); + + // store fee coins within price info object + price_info::deposit_fee_coins(price_info_object, fee); + + // Find price update corresponding to PriceInfoObject within the array of price_updates + // and use it to update PriceInfoObject. + let i = 0; + let found = false; + while (i < hot_potato_vector::length(&price_updates)){ + let cur_price_info = hot_potato_vector::borrow(&price_updates, i); + if (has_same_price_identifier(cur_price_info, price_info_object)){ + found = true; + update_cache(latest_only, cur_price_info, price_info_object, clock); + break + }; + i = i + 1; + }; + if (found==false){ + abort E_PRICE_UPDATE_NOT_FOUND_FOR_PRICE_INFO_OBJECT + }; + price_updates + } + + fun has_same_price_identifier(price_info: &PriceInfo, price_info_object: &PriceInfoObject) : bool { + let price_info_from_object = price_info::get_price_info_from_price_info_object(price_info_object); + let price_identifier_from_object = price_info::get_price_identifier(&price_info_from_object); + let price_identifier_from_price_info = price_info::get_price_identifier(price_info); + price_identifier_from_object == price_identifier_from_price_info + } + + /// Update PriceInfoObject with updated data from a PriceInfo + public(friend) fun update_cache( + _: LatestOnly, + update: &PriceInfo, + price_info_object: &mut PriceInfoObject, + clock: &Clock, + ){ + let has_same_price_identifier = has_same_price_identifier(update, price_info_object); + assert!(has_same_price_identifier, E_UPDATE_AND_PRICE_INFO_OBJECT_MISMATCH); + + // Update the price info object with the new updated price info. + if (is_fresh_update(update, price_info_object)){ + pyth_event::emit_price_feed_update(price_feed::from(price_info::get_price_feed(update)), clock::timestamp_ms(clock)/1000); + price_info::update_price_info_object( + price_info_object, + update + ); + } + } + + /// Determine if the given price update is "fresh": we have nothing newer already cached for that + /// price feed within a PriceInfoObject. + fun is_fresh_update(update: &PriceInfo, price_info_object: &PriceInfoObject): bool { + // Get the timestamp of the update's current price + let price_feed = price_info::get_price_feed(update); + let update_timestamp = price::get_timestamp(&price_feed::get_price(price_feed)); + + // Get the timestamp of the cached data for the price identifier + let cached_price_info = price_info::get_price_info_from_price_info_object(price_info_object); + let cached_price_feed = price_info::get_price_feed(&cached_price_info); + let cached_timestamp = price::get_timestamp(&price_feed::get_price(cached_price_feed)); + + update_timestamp > cached_timestamp + } + + // ----------------------------------------------------------------------------- + // Query the cached prices + // + // It is strongly recommended to update the cached prices using the functions above, + // before using the functions below to query the cached data. + + /// Determine if a price feed for the given price_identifier exists + public fun price_feed_exists(state: &PythState, price_identifier: PriceIdentifier): bool { + state::price_feed_object_exists(state, price_identifier) + } + + /// Get the latest available price cached for the given price identifier, if that price is + /// no older than the stale price threshold. + /// + /// Please refer to the documentation at https://docs.pyth.network/documentation/pythnet-price-feeds/best-practices for + /// how to how this price safely. + /// + /// Important: Pyth uses an on-demand update model, where consumers need to update the + /// cached prices before using them. Please read more about this at https://docs.pyth.network/documentation/pythnet-price-feeds/on-demand. + /// get_price() is likely to abort unless you call update_price_feeds() to update the cached price + /// beforehand, as the cached prices may be older than the stale price threshold. + /// + /// The price_info_object is a Iota object with the key ability that uniquely + /// contains a price feed for a given price_identifier. + /// + public fun get_price(state: &PythState, price_info_object: &PriceInfoObject, clock: &Clock): Price { + get_price_no_older_than(price_info_object, clock, state::get_stale_price_threshold_secs(state)) + } + + /// Get the latest available price cached for the given price identifier, if that price is + /// no older than the given age. + public fun get_price_no_older_than(price_info_object: &PriceInfoObject, clock: &Clock, max_age_secs: u64): Price { + let price = get_price_unsafe(price_info_object); + check_price_is_fresh(&price, clock, max_age_secs); + price + } + + /// Get the latest available price cached for the given price identifier. + /// + /// WARNING: the returned price can be from arbitrarily far in the past. + /// This function makes no guarantees that the returned price is recent or + /// useful for any particular application. Users of this function should check + /// the returned timestamp to ensure that the returned price is sufficiently + /// recent for their application. The checked get_price_no_older_than() + /// function should be used in preference to this. + public fun get_price_unsafe(price_info_object: &PriceInfoObject): Price { + // TODO: extract Price from this guy... + let price_info = price_info::get_price_info_from_price_info_object(price_info_object); + price_feed::get_price( + price_info::get_price_feed(&price_info) + ) + } + + fun abs_diff(x: u64, y: u64): u64 { + if (x > y) { + return x - y + } else { + return y - x + } + } + + /// Get the stale price threshold: the amount of time after which a cached price + /// is considered stale and no longer returned by get_price()/get_ema_price(). + public fun get_stale_price_threshold_secs(state: &PythState): u64 { + state::get_stale_price_threshold_secs(state) + } + + fun check_price_is_fresh(price: &Price, clock: &Clock, max_age_secs: u64) { + let age = abs_diff(clock::timestamp_ms(clock)/1000, price::get_timestamp(price)); + assert!(age < max_age_secs, E_STALE_PRICE_UPDATE); + } + + /// Please read more information about the update fee here: https://docs.pyth.network/documentation/pythnet-price-feeds/on-demand#fees + public fun get_total_update_fee(pyth_state: &PythState, n: u64): u64 { + state::get_base_update_fee(pyth_state) * n + } +} + +#[test_only] +module pyth::pyth_tests{ + use std::vector::{Self}; + + use iota::iota::IOTA; + use iota::coin::{Self, Coin}; + use iota::test_scenario::{Self, Scenario, ctx, take_shared, return_shared}; + use iota::package::Self; + use iota::object::{Self, ID}; + use iota::clock::{Self, Clock}; + + use pyth::state::{State as PythState}; + use pyth::setup::{Self}; + use pyth::price_info::{Self, PriceInfo, PriceInfoObject};//, PriceInfo, PriceInfoObject}; + use pyth::data_source::{Self, DataSource}; + use pyth::pyth::{Self, create_price_infos_hot_potato, update_single_price_feed}; + use pyth::hot_potato_vector::{Self}; + use pyth::price_identifier::{Self}; + use pyth::price_feed::{Self}; + use pyth::accumulator::{Self}; + use pyth::deserialize::{Self}; + + use wormhole::setup::{Self as wormhole_setup, DeployerCap}; + use wormhole::external_address::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::state::{State as WormState}; + use wormhole::vaa::{Self, VAA}; + use wormhole::cursor::{Self}; + + const DEPLOYER: address = @0x1234; + const ACCUMULATOR_TESTS_EMITTER_ADDRESS: vector = x"71f8dcb863d176e2c420ad6610cf687359612b6fb392e0642b0ca6b1f186aa3b"; + const ACCUMULATOR_TESTS_INITIAL_GUARDIANS: vector> = vector[x"7E5F4552091A69125d5DfCb7b8C2659029395Bdf"]; + const DEFAULT_BASE_UPDATE_FEE: u64 = 50; + const DEFAULT_COIN_TO_MINT: u64 = 5000; + const BATCH_ATTESTATION_TEST_INITIAL_GUARDIANS: vector> = vector[x"beFA429d57cD18b7F8A4d91A2da9AB4AF05d0FBe"]; + + fun ACCUMULATOR_TESTS_DATA_SOURCE(): vector { + vector[data_source::new(1, external_address::new(bytes32::from_bytes(ACCUMULATOR_TESTS_EMITTER_ADDRESS)))] + } + + fun get_verified_test_vaas(worm_state: &WormState, clock: &Clock): vector { + let test_vaas_: vector> = vector[x"0100000000010036eb563b80a24f4253bee6150eb8924e4bdf6e4fa1dfc759a6664d2e865b4b134651a7b021b7f1ce3bd078070b688b6f2e37ce2de0d9b48e6a78684561e49d5201527e4f9b00000001001171f8dcb863d176e2c420ad6610cf687359612b6fb392e0642b0ca6b1f186aa3b0000000000000001005032574800030000000102000400951436e0be37536be96f0896366089506a59763d036728332d3e3038047851aea7c6c75c89f14810ec1c54c03ab8f1864a4c4032791f05747f560faec380a695d1000000000000049a0000000000000008fffffffb00000000000005dc0000000000000003000000000100000001000000006329c0eb000000006329c0e9000000006329c0e400000000000006150000000000000007215258d81468614f6b7e194c5d145609394f67b041e93e6695dcc616faadd0603b9551a68d01d954d6387aff4df1529027ffb2fee413082e509feb29cc4904fe000000000000041a0000000000000003fffffffb00000000000005cb0000000000000003010000000100000001000000006329c0eb000000006329c0e9000000006329c0e4000000000000048600000000000000078ac9cf3ab299af710d735163726fdae0db8465280502eb9f801f74b3c1bd190333832fad6e36eb05a8972fe5f219b27b5b2bb2230a79ce79beb4c5c5e7ecc76d00000000000003f20000000000000002fffffffb00000000000005e70000000000000003010000000100000001000000006329c0eb000000006329c0e9000000006329c0e40000000000000685000000000000000861db714e9ff987b6fedf00d01f9fea6db7c30632d6fc83b7bc9459d7192bc44a21a28b4c6619968bd8c20e95b0aaed7df2187fd310275347e0376a2cd7427db800000000000006cb0000000000000001fffffffb00000000000005e40000000000000003010000000100000001000000006329c0eb000000006329c0e9000000006329c0e400000000000007970000000000000001"]; + let verified_vaas_reversed = vector::empty(); + let test_vaas = test_vaas_; + let i = 0; + while (i < vector::length(&test_vaas_)) { + let cur_test_vaa = vector::pop_back(&mut test_vaas); + let verified_vaa = vaa::parse_and_verify(worm_state, cur_test_vaa, clock); + vector::push_back(&mut verified_vaas_reversed, verified_vaa); + i=i+1; + }; + let verified_vaas = vector::empty(); + while (vector::length(&verified_vaas_reversed)!=0){ + let cur = vector::pop_back(&mut verified_vaas_reversed); + vector::push_back(&mut verified_vaas, cur); + }; + vector::destroy_empty(verified_vaas_reversed); + verified_vaas + } + + // get_verified_vaa_from_accumulator_message parses the accumulator message up until the vaa, then + // parses the vaa, yielding a verified wormhole::vaa::VAA object + fun get_verified_vaa_from_accumulator_message(worm_state: &WormState, accumulator_message: vector, clock: &Clock): VAA { + let _PYTHNET_ACCUMULATOR_UPDATE_MAGIC: u64 = 1347305813; + + let cursor = cursor::new(accumulator_message); + let header: u32 = deserialize::deserialize_u32(&mut cursor); + assert!((header as u64) == _PYTHNET_ACCUMULATOR_UPDATE_MAGIC, 0); + let _major = deserialize::deserialize_u8(&mut cursor); + let _minor = deserialize::deserialize_u8(&mut cursor); + + let trailing_size = deserialize::deserialize_u8(&mut cursor); + deserialize::deserialize_vector(&mut cursor, (trailing_size as u64)); + + let proof_type = deserialize::deserialize_u8(&mut cursor); + assert!(proof_type == 0, 0); + + let vaa_size = deserialize::deserialize_u16(&mut cursor); + let vaa = deserialize::deserialize_vector(&mut cursor, (vaa_size as u64)); + cursor::take_rest(cursor); + vaa::parse_and_verify(worm_state, vaa, clock) + } + + #[test_only] + /// Init Wormhole core bridge state. + /// Init Pyth state. + /// Set initial Iota clock time. + /// Mint some IOTA fee coins. + public fun setup_test( + stale_price_threshold: u64, + governance_emitter_chain_id: u64, + governance_emitter_address: vector, + data_sources: vector, + initial_guardians: vector>, + base_update_fee: u64, + to_mint: u64 + ): (Scenario, Coin, Clock) { + + let scenario = test_scenario::begin(DEPLOYER); + + // Initialize Wormhole core bridge. + wormhole_setup::init_test_only(ctx(&mut scenario)); + test_scenario::next_tx(&mut scenario, DEPLOYER); + // Take the `DeployerCap` from the sender of the transaction. + let deployer_cap = + test_scenario::take_from_address( + &scenario, + DEPLOYER + ); + + // This will be created and sent to the transaction sender automatically + // when the contract is published. This exists in place of grabbing + // it from the sender. + let upgrade_cap = + package::test_publish( + object::id_from_address(@wormhole), + test_scenario::ctx(&mut scenario) + ); + + let governance_chain = 1234; + let governance_contract = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + let guardian_set_seconds_to_live = 5678; + let message_fee = 350; + let guardian_set_index = 0; + wormhole_setup::complete( + deployer_cap, + upgrade_cap, + governance_chain, + governance_contract, + guardian_set_index, + initial_guardians, + guardian_set_seconds_to_live, + message_fee, + test_scenario::ctx(&mut scenario) + ); + + // Initialize Pyth state. + let pyth_upgrade_cap= + package::test_publish( + object::id_from_address(@pyth), + test_scenario::ctx(&mut scenario) + ); + + setup::init_test_only(ctx(&mut scenario)); + test_scenario::next_tx(&mut scenario, DEPLOYER); + let pyth_deployer_cap = test_scenario::take_from_address( + &scenario, + DEPLOYER + ); + + setup::init_and_share_state( + pyth_deployer_cap, + pyth_upgrade_cap, + stale_price_threshold, + base_update_fee, + data_source::new(governance_emitter_chain_id, external_address::new(bytes32::from_bytes(governance_emitter_address))), + data_sources, + ctx(&mut scenario) + ); + + let coins = coin::mint_for_testing(to_mint, ctx(&mut scenario)); + let clock = clock::create_for_testing(ctx(&mut scenario)); + (scenario, coins, clock) + } + + fun get_mock_price_infos(): vector { + use pyth::i64::Self; + use pyth::price::{Self}; + vector[ + price_info::new_price_info( + 1663680747, + 1663074349, + price_feed::new( + price_identifier::from_byte_vec(x"c6c75c89f14810ec1c54c03ab8f1864a4c4032791f05747f560faec380a695d1"), + price::new(i64::new(1557, false), 7, i64::new(5, true), 1663680740), + price::new(i64::new(1500, false), 3, i64::new(5, true), 1663680740), + ), + ), + price_info::new_price_info( + 1663680747, + 1663074349, + price_feed::new( + price_identifier::from_byte_vec(x"3b9551a68d01d954d6387aff4df1529027ffb2fee413082e509feb29cc4904fe"), + price::new(i64::new(1050, false), 3, i64::new(5, true), 1663680745), + price::new(i64::new(1483, false), 3, i64::new(5, true), 1663680745), + ), + ), + price_info::new_price_info( + 1663680747, + 1663074349, + price_feed::new( + price_identifier::from_byte_vec(x"33832fad6e36eb05a8972fe5f219b27b5b2bb2230a79ce79beb4c5c5e7ecc76d"), + price::new(i64::new(1010, false), 2, i64::new(5, true), 1663680745), + price::new(i64::new(1511, false), 3, i64::new(5, true), 1663680745), + ), + ), + price_info::new_price_info( + 1663680747, + 1663074349, + price_feed::new( + price_identifier::from_byte_vec(x"21a28b4c6619968bd8c20e95b0aaed7df2187fd310275347e0376a2cd7427db8"), + price::new(i64::new(1739, false), 1, i64::new(5, true), 1663680745), + price::new(i64::new(1508, false), 3, i64::new(5, true), 1663680745), + ), + ), + ] + } + + /// Compare the expected price feed with the actual Pyth price feeds. + fun check_price_feeds_cached(expected: &vector, actual: &vector) { + // Check that we can retrieve the correct current price and ema price for each price feed + let i = 0; + while (i < vector::length(expected)) { + let price_feed = price_info::get_price_feed(vector::borrow(expected, i)); + let price = price_feed::get_price(price_feed); + let ema_price = price_feed::get_ema_price(price_feed); + let price_identifier = price_info::get_price_identifier(vector::borrow(expected, i)); + + let actual_price_info = price_info::get_price_info_from_price_info_object(vector::borrow(actual, i)); + let actual_price_feed = price_info::get_price_feed(&actual_price_info); + let actual_price = price_feed::get_price(actual_price_feed); + let actual_ema_price = price_feed::get_ema_price(actual_price_feed); + let actual_price_identifier = price_info::get_price_identifier(&actual_price_info); + + assert!(price == actual_price, 0); + assert!(ema_price == actual_ema_price, 0); + assert!(price_identifier::get_bytes(&price_identifier) == price_identifier::get_bytes(&actual_price_identifier), 0); + + i = i + 1; + }; + } + + #[test] + fun test_get_update_fee() { + let (scenario, test_coins, _clock) = setup_test(500 /* stale_price_threshold */, 23 /* governance emitter chain */, x"5d1f252d5de865279b00c84bce362774c2804294ed53299bc4a0389a5defef92", vector[], BATCH_ATTESTATION_TEST_INITIAL_GUARDIANS, DEFAULT_BASE_UPDATE_FEE, 0); + test_scenario::next_tx(&mut scenario, DEPLOYER, ); + let pyth_state = take_shared(&scenario); + // Pass in a single VAA + + let single_vaa = vector[ + x"fb1543888001083cf2e6ef3afdcf827e89b11efd87c563638df6e1995ada9f93", + ]; + + assert!(pyth::get_total_update_fee(&pyth_state, vector::length>(&single_vaa)) == DEFAULT_BASE_UPDATE_FEE, 1); + + let multiple_vaas = vector[ + x"4ee17a1a4524118de513fddcf82b77454e51be5d6fc9e29fc72dd6c204c0e4fa", + x"c72fdf81cfc939d4286c93fbaaae2eec7bae28a5926fa68646b43a279846ccc1", + x"d9a8123a793529c31200339820a3210059ecace6c044f81ecad62936e47ca049", + x"84e4f21b3e65cef47fda25d15b4eddda1edf720a1d062ccbf441d6396465fbe6", + x"9e73f9041476a93701a0b9c7501422cc2aa55d16100bec628cf53e0281b6f72f" + ]; + + // Pass in multiple VAAs + assert!(pyth::get_total_update_fee(&pyth_state, vector::length>(&multiple_vaas)) == 5*DEFAULT_BASE_UPDATE_FEE, 1); + + return_shared(pyth_state); + coin::burn_for_testing(test_coins); + clock::destroy_for_testing(_clock); + test_scenario::end(scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::vaa::E_WRONG_VERSION)] + fun test_create_price_feeds_corrupt_vaa() { + let (scenario, test_coins, clock) = setup_test(500 /* stale_price_threshold */, 23 /* governance emitter chain */, x"5d1f252d5de865279b00c84bce362774c2804294ed53299bc4a0389a5defef92", vector[], vector[x"beFA429d57cD18b7F8A4d91A2da9AB4AF05d0FBe"], 50, 0); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + // Pass in a corrupt VAA, which should fail deserializing + let corrupt_vaa = x"90F8bf6A479f320ead074411a4B0e7944Ea8c9C1"; + let verified_vaas = vector[vaa::parse_and_verify(&worm_state, corrupt_vaa, &clock)]; + // Create Pyth price feed + pyth::create_price_feeds( + &mut pyth_state, + verified_vaas, + &clock, + ctx(&mut scenario) + ); + + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + coin::burn_for_testing(test_coins); + test_scenario::end(scenario); + } + + #[test] + #[expected_failure(abort_code = pyth::pyth::E_INVALID_DATA_SOURCE)] + fun test_create_price_feeds_invalid_data_source() { + // Initialize the contract with some valid data sources, excluding our test VAA's source + let data_sources = vector[ + data_source::new( + 4, external_address::new(bytes32::new(x"0000000000000000000000000000000000000000000000000000000000007742")) + ), + data_source::new( + 5, external_address::new(bytes32::new(x"0000000000000000000000000000000000000000000000000000000000007637")) + ) + ]; + let (scenario, test_coins, clock) = setup_test(500, 23, x"5d1f252d5de865279b00c84bce362774c2804294ed53299bc4a0389a5defef92", data_sources, BATCH_ATTESTATION_TEST_INITIAL_GUARDIANS, 50, 0); + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + let verified_vaas = get_verified_test_vaas(&worm_state, &clock); + + pyth::create_price_feeds( + &mut pyth_state, + verified_vaas, + &clock, + ctx(&mut scenario) + ); + + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + coin::burn_for_testing(test_coins); + test_scenario::end(scenario); + } + + public fun data_sources_for_test_vaa(): vector { + // Set some valid data sources, including our test VAA's source + vector[ + data_source::new( + 1, external_address::new(bytes32::from_bytes(x"0000000000000000000000000000000000000000000000000000000000000004"))), + data_source::new( + 5, external_address::new(bytes32::new(x"0000000000000000000000000000000000000000000000000000000000007637"))), + data_source::new( + 17, external_address::new(bytes32::new(ACCUMULATOR_TESTS_EMITTER_ADDRESS))) + ] + } + + #[test] + // test_create_and_update_price_feeds_with_batch_attestation_success tests the creation and updating of price + // feeds, as well as depositing fee coins into price info objects + fun test_create_and_update_price_feeds_with_batch_attestation_success() { + let (scenario, test_coins, clock) = setup_test(500, 23, x"5d1f252d5de865279b00c84bce362774c2804294ed53299bc4a0389a5defef92", data_sources_for_test_vaa(), vector[x"beFA429d57cD18b7F8A4d91A2da9AB4AF05d0FBe"], DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + let verified_vaas = get_verified_test_vaas(&worm_state, &clock); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::create_price_feeds( + &mut pyth_state, + verified_vaas, + &clock, + ctx(&mut scenario) + ); + + // Affirm that 4 objects, which correspond to the 4 new price info objects + // containing the price feeds were created and shared. + let effects = test_scenario::next_tx(&mut scenario, DEPLOYER); + let shared_ids = test_scenario::shared(&effects); + let created_ids = test_scenario::created(&effects); + assert!(vector::length(&shared_ids)==4, 0); + assert!(vector::length(&created_ids)==4, 0); + + let price_info_object_1 = take_shared(&scenario); + let price_info_object_2 = take_shared(&scenario); + let price_info_object_3 = take_shared(&scenario); + let price_info_object_4 = take_shared(&scenario); + + // Create vector of price info objects (Iota objects with key ability and living in global store), + // which contain the price feeds we want to update. Note that these can be passed into + // update_price_feeds in any order! + //let price_info_object_vec = vector[price_info_object_1, price_info_object_2, price_info_object_3, price_info_object_4]; + verified_vaas = get_verified_test_vaas(&worm_state, &clock); + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let vaa_1 = vector::pop_back(&mut verified_vaas); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + // Create authenticated price infos + let vec = create_price_infos_hot_potato( + &pyth_state, + vector[vaa_1], + &clock + ); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let fee_coins = coin::split(&mut test_coins, DEFAULT_BASE_UPDATE_FEE, ctx(&mut scenario)); + vec = update_single_price_feed( + &pyth_state, + vec, + &mut price_info_object_1, + fee_coins, + &clock + ); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + // check price feed updated + assert!(price_feeds_equal(hot_potato_vector::borrow(&vec, 3), &price_info::get_price_info_from_price_info_object(&price_info_object_1)), 0); + + // check fee coins are deposited in the price info object + assert!(price_info::get_balance(&price_info_object_1)==DEFAULT_BASE_UPDATE_FEE, 0); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + hot_potato_vector::destroy(vec); + + vector::destroy_empty(verified_vaas); + return_shared(price_info_object_1); + return_shared(price_info_object_2); + return_shared(price_info_object_3); + return_shared(price_info_object_4); + + coin::burn_for_testing(test_coins); + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } + + + // TEST_ACCUMULATOR_SINGLE_FEED details: + // Price Identifier: 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6 + // Price: 6887568746747646632 + // Conf: 13092246197863718329 + // Exponent: 1559537863 + // EMA Price: 4772242609775910581 + // EMA Conf: 358129956189946877 + // EMA Expo: 1559537863 + // Published Time: 1687276661 + const TEST_ACCUMULATOR_SINGLE_FEED: vector = x"504e41550100000000a0010000000001005d461ac1dfffa8451edda17e4b28a46c8ae912422b2dc0cb7732828c497778ea27147fb95b4d250651931845e7f3e22c46326716bcf82be2874a9c9ab94b6e42000000000000000000000171f8dcb863d176e2c420ad6610cf687359612b6fb392e0642b0ca6b1f186aa3b0000000000000000004155575600000000000000000000000000da936d73429246d131873a0bab90ad7b416510be01005500b10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf65f958f4883f9d2a8b5b1008d1fa01db95cf4a8c7000000006491cc757be59f3f377c0d3f423a695e81ad1eb504f8554c3620c3fd02f2ee15ea639b73fa3db9b34a245bdfa015c260c5a8a1180177cf30b2c0bebbb1adfe8f7985d051d2"; + + #[test] + fun test_create_and_update_single_price_feed_with_accumulator_success() { + let (scenario, coins, clock) = setup_test(500, 23, ACCUMULATOR_TESTS_EMITTER_ADDRESS, ACCUMULATOR_TESTS_DATA_SOURCE(), ACCUMULATOR_TESTS_INITIAL_GUARDIANS, DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + let verified_vaa = get_verified_vaa_from_accumulator_message(&worm_state, TEST_ACCUMULATOR_SINGLE_FEED, &clock); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::create_price_feeds_using_accumulator( + &mut pyth_state, + TEST_ACCUMULATOR_SINGLE_FEED, + verified_vaa, + &clock, + ctx(&mut scenario) + ); + + // Affirm that 1 object, which correspond to the 1 new price info object + // containing the price feeds were created and shared. + let effects = test_scenario::next_tx(&mut scenario, DEPLOYER); + let shared_ids = test_scenario::shared(&effects); + let created_ids = test_scenario::created(&effects); + assert!(vector::length(&shared_ids)==1, 0); + assert!(vector::length(&created_ids)==1, 0); + + let price_info_object_1 = take_shared(&scenario); + + // Create authenticated price infos + verified_vaa = get_verified_vaa_from_accumulator_message(&worm_state, TEST_ACCUMULATOR_SINGLE_FEED, &clock); + let auth_price_infos = pyth::create_authenticated_price_infos_using_accumulator( + &pyth_state, + TEST_ACCUMULATOR_SINGLE_FEED, + verified_vaa, + &clock + ); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + auth_price_infos = update_single_price_feed( + &pyth_state, + auth_price_infos, + &mut price_info_object_1, + coins, + &clock + ); + + // assert that price info obejct is as expected + let expected = accumulator_test_1_to_price_info(); + assert!(price_feeds_equal(&expected, &price_info::get_price_info_from_price_info_object(&price_info_object_1)), 0); + + // clean up test scenario + + test_scenario::next_tx(&mut scenario, DEPLOYER); + hot_potato_vector::destroy(auth_price_infos); + + return_shared(price_info_object_1); + + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } + + #[test] + #[expected_failure(abort_code = pyth::accumulator::E_INVALID_PROOF)] + fun test_create_and_update_single_price_feed_with_accumulator_failure() { + + let (scenario, coins, clock) = setup_test(500, 23, ACCUMULATOR_TESTS_EMITTER_ADDRESS, ACCUMULATOR_TESTS_DATA_SOURCE(), ACCUMULATOR_TESTS_INITIAL_GUARDIANS, DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + // the verified vaa here contains the wrong merkle root + let verified_vaa = get_verified_vaa_from_accumulator_message(&worm_state, TEST_ACCUMULATOR_3_MSGS, &clock); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::create_price_feeds_using_accumulator( + &mut pyth_state, + TEST_ACCUMULATOR_SINGLE_FEED, + verified_vaa, + &clock, + ctx(&mut scenario) + ); + + // clean up test scenario + test_scenario::next_tx(&mut scenario, DEPLOYER); + coin::burn_for_testing(coins); + + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } + + #[test_only] + const TEST_ACCUMULATOR_INVALID_PROOF_1: vector = x"504e41550100000000a001000000000100110db9cd8325ccfab0dae92eeb9ea70a1faba5c5e96dc21ff46a8ddc560afc9a60df096b8ff21172804692bbdc958153e838437d8b474cbf45f0dc2a8acae831000000000000000000000171f8dcb863d176e2c420ad6610cf687359612b6fb392e0642b0ca6b1f186aa3b0000000000000000004155575600000000000000000000000000a8bea2b5f12f3177ff9b3929d77c3476ab2d32c602005500b10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6fa75cd3aa3bb5ace5e2516446f71f85be36bd19bb0703f3154bb3db07be59f3f377c0d3f44661d9a8736c68884c8169e8b636ee3043202397384073120dce9e5d0efe24b44b4a0d62da8a1180177cf30b2c0bebbb1adfe8f7985d051d205a01e2504d9f0c06e7e7cb0cf24116098ca202ac5f6ade2e8f5a12ec006b16d46be1f0228b94d950055006e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af5f958f4883f9d2a8b5b1008d1fa01db95cf4a8c7423a695e81ad1eb504f8554c3620c3fd40b40f7d581ac802e2de5cb82a9ae672043202397384073120dce9e5d0efe24b44b4a0d62da8a1180177cf30b2c0bebbb1adfe8f7985d051d205a01e2504d9f0c06e7e7cb0cf24116098ca202ac5f6ade2e8f5a12ec006b16d46be1f0228b94d95"; + + #[test] + #[expected_failure(abort_code = pyth::accumulator::E_INVALID_PROOF)] + fun test_accumulator_invalid_proof() { + + let (scenario, coins, clock) = setup_test(500, 23, ACCUMULATOR_TESTS_EMITTER_ADDRESS, ACCUMULATOR_TESTS_DATA_SOURCE(), ACCUMULATOR_TESTS_INITIAL_GUARDIANS, DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + let verified_vaa = get_verified_vaa_from_accumulator_message(&worm_state, TEST_ACCUMULATOR_INVALID_PROOF_1, &clock); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::create_price_feeds_using_accumulator( + &mut pyth_state, + TEST_ACCUMULATOR_INVALID_PROOF_1, + verified_vaa, + &clock, + ctx(&mut scenario) + ); + + // clean up test scenario + test_scenario::next_tx(&mut scenario, DEPLOYER); + coin::burn_for_testing(coins); + + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } + + #[test_only] + const TEST_ACCUMULATOR_INVALID_MAJOR_VERSION: vector = x"504e41553c00000000a001000000000100496b7fbd18dca2f0e690712fd8ca522ff79ca7d9d6d22e9f5d753fba4bd16fff440a811bad710071c79859290bcb1700de49dd8400db90b048437b521200123e010000000000000000000171f8dcb863d176e2c420ad6610cf687359612b6fb392e0642b0ca6b1f186aa3b000000000000000000415557560000000000000000000000000005f5db4488a7cae9f9a6c1938340c0fbf4beb9090200550031ecc21a745e3968a04e9570e4425bc18fa8019c68028196b546d1669c200c6879bc5a3617ec3444d93c06501cf6a0909c38d4ec81d96026b71ec475e87d69c7b5124289adbf24212bed8c15db354391d2378d2e0454d2655c6c34e7e50580fd8c94511322968bbc6da8a1180177cf30b2c0bebbb1adfe8f7985d051d205a01e2504d9f0c06e7e7cb0cf24116098ca202ac5f6ade2e8f5a12ec006b16d46be1f0228b94d95005500944998273e477b495144fb8794c914197f3ccb46be2900f4698fd0ef743c9695a573a6ff665ff63edb5f9a85ad579dc14500a2112c09680fc146134f9a539ca82cb6e3501c801278fd08d80732a24118292866bb049e6e88181a1e1e8b6d3c6bbb95135a73041f3b56a8a1180177cf30b2c0bebbb1adfe8f7985d051d205a01e2504d9f0c06e7e7cb0cf24116098ca202ac5f6ade2e8f5a12ec006b16d46be1f0228b94d95"; + + #[test] + #[expected_failure(abort_code = pyth::accumulator::E_INVALID_ACCUMULATOR_PAYLOAD)] + fun test_accumulator_invalid_major_version() { + + let (scenario, coins, clock) = setup_test(500, 23, ACCUMULATOR_TESTS_EMITTER_ADDRESS, ACCUMULATOR_TESTS_DATA_SOURCE(), ACCUMULATOR_TESTS_INITIAL_GUARDIANS, DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + let verified_vaa = get_verified_vaa_from_accumulator_message(&worm_state, TEST_ACCUMULATOR_INVALID_MAJOR_VERSION, &clock); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::create_price_feeds_using_accumulator( + &mut pyth_state, + TEST_ACCUMULATOR_INVALID_MAJOR_VERSION, + verified_vaa, + &clock, + ctx(&mut scenario) + ); + + // clean up test scenario + test_scenario::next_tx(&mut scenario, DEPLOYER); + coin::burn_for_testing(coins); + + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } + + #[test_only] + const TEST_ACCUMULATOR_INVALID_WH_MSG: vector = x"504e41550100000000a001000000000100e87f98238c5357730936cfdfde3a37249e5219409a4f41b301924b8eb10815a43ea2f96e4fe1bc8cd398250f39448d3b8ca57c96f9cf7a2be292517280683caa010000000000000000000171f8dcb863d176e2c420ad6610cf687359612b6fb392e0642b0ca6b1f186aa3b00000000000000000041555755000000000000000000000000000fb6f9f2b3b6cc1c9ef6708985fef226d92a3c0801005500b10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6fa75cd3aa3bb5ace5e2516446f71f85be36bd19b000000006491cc747be59f3f377c0d3f44661d9a8736c68884c8169e8b636ee301f2ee15ea639b73fa3db9b34a245bdfa015c260c5"; + + #[test] + #[expected_failure(abort_code = pyth::accumulator::E_INVALID_WORMHOLE_MESSAGE)] + fun test_accumulator_invalid_wormhole_message() { + + let (scenario, coins, clock) = setup_test(500, 23, ACCUMULATOR_TESTS_EMITTER_ADDRESS, ACCUMULATOR_TESTS_DATA_SOURCE(), ACCUMULATOR_TESTS_INITIAL_GUARDIANS, DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + let verified_vaa = get_verified_vaa_from_accumulator_message(&worm_state, TEST_ACCUMULATOR_INVALID_WH_MSG, &clock); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::create_price_feeds_using_accumulator( + &mut pyth_state, + TEST_ACCUMULATOR_INVALID_WH_MSG, + verified_vaa, + &clock, + ctx(&mut scenario) + ); + + // clean up test scenario + test_scenario::next_tx(&mut scenario, DEPLOYER); + coin::burn_for_testing(coins); + + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } + + + #[test_only] + const TEST_ACCUMULATOR_INCREASED_MINOR_VERSION: vector = x"504e4155010a000000a001000000000100496b7fbd18dca2f0e690712fd8ca522ff79ca7d9d6d22e9f5d753fba4bd16fff440a811bad710071c79859290bcb1700de49dd8400db90b048437b521200123e010000000000000000000171f8dcb863d176e2c420ad6610cf687359612b6fb392e0642b0ca6b1f186aa3b000000000000000000415557560000000000000000000000000005f5db4488a7cae9f9a6c1938340c0fbf4beb9090200550031ecc21a745e3968a04e9570e4425bc18fa8019c68028196b546d1669c200c6879bc5a3617ec3444d93c06501cf6a0909c38d4ec81d96026b71ec475e87d69c7b5124289adbf24212bed8c15db354391d2378d2e0454d2655c6c34e7e50580fd8c94511322968bbc6da8a1180177cf30b2c0bebbb1adfe8f7985d051d205a01e2504d9f0c06e7e7cb0cf24116098ca202ac5f6ade2e8f5a12ec006b16d46be1f0228b94d95005500944998273e477b495144fb8794c914197f3ccb46be2900f4698fd0ef743c9695a573a6ff665ff63edb5f9a85ad579dc14500a2112c09680fc146134f9a539ca82cb6e3501c801278fd08d80732a24118292866bb049e6e88181a1e1e8b6d3c6bbb95135a73041f3b56a8a1180177cf30b2c0bebbb1adfe8f7985d051d205a01e2504d9f0c06e7e7cb0cf24116098ca202ac5f6ade2e8f5a12ec006b16d46be1f0228b94d95"; + #[test_only] + const TEST_ACCUMULATOR_EXTRA_PAYLOAD: vector = x"504e41550100000000a001000000000100b2d11f181d81b4ff10beca30091754b464dc48bc1f7432d114f64a7a8f660e7964f2a0c6121bae6c1977514d46ee7a29d9395b20a45f2086071715c1dc19ab74000000000000000000000171f8dcb863d176e2c420ad6610cf687359612b6fb392e0642b0ca6b1f186aa3b000000000000000000415557560000000000000000000000000013f83cfdf63a5a1b3189182fa0a52e6de53ba7d002005d0031ecc21a745e3968a04e9570e4425bc18fa8019c68028196b546d1669c200c6879bc5a3617ec3444d93c06501cf6a0909c38d4ec81d96026b71ec475e87d69c7b5124289adbf24212bed8c15db354391d2378d2e000000000000000004a576f4a87f443f7d961a682f508c4f7b06ee1595a8a1180177cf30b2c0bebbb1adfe8f7985d051d205a01e2504d9f0c06e7e7cb0cf24116098ca202ac5f6ade2e8f5a12ec006b16d46be1f0228b94d95005d00944998273e477b495144fb8794c914197f3ccb46be2900f4698fd0ef743c9695a573a6ff665ff63edb5f9a85ad579dc14500a2112c09680fc146134f9a539ca82cb6e3501c801278fd08d80732a24118292866bb0000000000000000045be67ba87a8dfbea404827ccbf07790299b6c023a8a1180177cf30b2c0bebbb1adfe8f7985d051d205a01e2504d9f0c06e7e7cb0cf24116098ca202ac5f6ade2e8f5a12ec006b16d46be1f0228b94d95"; + + #[test] + fun test_accumulator_forward_compatibility() { + + let (scenario, coins, clock) = setup_test(500, 23, ACCUMULATOR_TESTS_EMITTER_ADDRESS, ACCUMULATOR_TESTS_DATA_SOURCE(), ACCUMULATOR_TESTS_INITIAL_GUARDIANS, DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::create_price_feeds_using_accumulator( + &mut pyth_state, + TEST_ACCUMULATOR_EXTRA_PAYLOAD, + get_verified_vaa_from_accumulator_message(&worm_state, TEST_ACCUMULATOR_EXTRA_PAYLOAD, &clock), + &clock, + ctx(&mut scenario) + ); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::create_price_feeds_using_accumulator( + &mut pyth_state, + TEST_ACCUMULATOR_INCREASED_MINOR_VERSION, + get_verified_vaa_from_accumulator_message(&worm_state, TEST_ACCUMULATOR_INCREASED_MINOR_VERSION, &clock), + &clock, + ctx(&mut scenario) + ); + + // clean up test scenario + test_scenario::next_tx(&mut scenario, DEPLOYER); + coin::burn_for_testing(coins); + + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } + + + // TEST_ACCUMULATOR_3_MSGS details: + // Price Identifier: 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6 + // Price: 100 + // Conf: 50 + // Exponent: 9 + // EMA Price: 99 + // EMA Conf: 52 + // EMA Expo: 9 + // Published Time: 1687276660 + + // Price Identifier: 0x6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af + // Price: 101 + // Conf: 51 + // Exponent: 10 + // EMA Price: 100 + // EMA Conf: 53 + // EMA Expo: 10 + // Published Time: 1687276661 + + // Price Identifier: 0x31ecc21a745e3968a04e9570e4425bc18fa8019c68028196b546d1669c200c68 + // Price: 102 + // Conf: 52 + // Exponent: 11 + // EMA Price: 101 + // EMA Conf: 54 + // EMA Expo: 11 + // Published Time: 1687276662 + const TEST_ACCUMULATOR_3_MSGS: vector = x"504e41550100000000a001000000000100d39b55fa311213959f91866d52624f3a9c07350d8956f6d42cfbb037883f31575c494a2f09fea84e4884dc9c244123fd124bc7825cd64d7c11e33ba5cfbdea7e010000000000000000000171f8dcb863d176e2c420ad6610cf687359612b6fb392e0642b0ca6b1f186aa3b000000000000000000415557560000000000000000000000000029da4c066b6e03b16a71e77811570dd9e19f258103005500b10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf60000000000000064000000000000003200000009000000006491cc747be59f3f377c0d3f000000000000006300000000000000340436992facb15658a7e9f08c4df4848ca80750f61fadcd96993de66b1fe7aef94e29e3bbef8b12db2305a01e2504d9f0c06e7e7cb0cf24116098ca202ac5f6ade2e8f5a12ec006b16d46be1f0228b94d950055006e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af000000000000006500000000000000330000000a000000006491cc7504f8554c3620c3fd0000000000000064000000000000003504171ed10ac4f1eacf3a4951e1da6b119f07c45da5adcd96993de66b1fe7aef94e29e3bbef8b12db2305a01e2504d9f0c06e7e7cb0cf24116098ca202ac5f6ade2e8f5a12ec006b16d46be1f0228b94d9500550031ecc21a745e3968a04e9570e4425bc18fa8019c68028196b546d1669c200c68000000000000006600000000000000340000000b000000006491cc76e87d69c7b51242890000000000000065000000000000003604f2ee15ea639b73fa3db9b34a245bdfa015c260c5fe83e4772e0e346613de00e5348158a01bcb27b305a01e2504d9f0c06e7e7cb0cf24116098ca202ac5f6ade2e8f5a12ec006b16d46be1f0228b94d95"; + + #[test] + fun test_create_and_update_multiple_price_feeds_with_accumulator_success() { + use iota::coin::Self; + + let (scenario, coins, clock) = setup_test(500, 23, ACCUMULATOR_TESTS_EMITTER_ADDRESS, ACCUMULATOR_TESTS_DATA_SOURCE(), ACCUMULATOR_TESTS_INITIAL_GUARDIANS, DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + let verified_vaa = get_verified_vaa_from_accumulator_message(&worm_state, TEST_ACCUMULATOR_3_MSGS, &clock); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::create_price_feeds_using_accumulator( + &mut pyth_state, + TEST_ACCUMULATOR_3_MSGS, + verified_vaa, + &clock, + ctx(&mut scenario) + ); + + // Affirm that 3 objects, which correspond to the 3 new price info objects + // containing the price feeds were created and shared. + let effects = test_scenario::next_tx(&mut scenario, DEPLOYER); + let shared_ids = test_scenario::shared(&effects); + let created_ids = test_scenario::created(&effects); + assert!(vector::length(&shared_ids)==3, 0); + assert!(vector::length(&created_ids)==3, 0); + + // Create authenticated price infos + verified_vaa = get_verified_vaa_from_accumulator_message(&worm_state, TEST_ACCUMULATOR_3_MSGS, &clock); + let auth_price_infos = pyth::create_authenticated_price_infos_using_accumulator( + &pyth_state, + TEST_ACCUMULATOR_3_MSGS, + verified_vaa, + &clock + ); + + let idx = 0; + let expected_price_infos = accumulator_test_3_to_price_info(0 /*offset argument*/); + + while (idx < 3){ + let coin_split = coin::split(&mut coins, 1000, ctx(&mut scenario)); + let price_info_object = take_shared(&scenario); + auth_price_infos = update_single_price_feed( + &pyth_state, + auth_price_infos, + &mut price_info_object, + coin_split, + &clock + ); + let price_info = price_info::get_price_info_from_price_info_object(&price_info_object); + assert!(price_feeds_equal(&price_info, vector::borrow(&expected_price_infos, idx)), 0); + return_shared(price_info_object); + idx = idx + 1; + }; + coin::burn_for_testing(coins); + + // clean up test scenario + test_scenario::next_tx(&mut scenario, DEPLOYER); + hot_potato_vector::destroy(auth_price_infos); + + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } + + #[test] + #[expected_failure(abort_code = pyth::pyth::E_INSUFFICIENT_FEE)] + fun test_create_and_update_price_feeds_insufficient_fee() { + + // this is not enough fee and will cause a failure + let coins_to_mint = 1; + + let (scenario, test_coins, clock) = setup_test(500, 23, x"5d1f252d5de865279b00c84bce362774c2804294ed53299bc4a0389a5defef92", data_sources_for_test_vaa(), vector[x"beFA429d57cD18b7F8A4d91A2da9AB4AF05d0FBe"], DEFAULT_BASE_UPDATE_FEE, coins_to_mint); + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + let verified_vaas = get_verified_test_vaas(&worm_state, &clock); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + pyth::create_price_feeds( + &mut pyth_state, + verified_vaas, + &clock, + ctx(&mut scenario) + ); + + // Affirm that 4 objects, which correspond to the 4 new price info objects + // containing the price feeds were created and shared. + let effects = test_scenario::next_tx(&mut scenario, DEPLOYER); + let shared_ids = test_scenario::shared(&effects); + let created_ids = test_scenario::created(&effects); + assert!(vector::length(&shared_ids)==4, 0); + assert!(vector::length(&created_ids)==4, 0); + + let price_info_object_1 = take_shared(&scenario); + let price_info_object_2 = take_shared(&scenario); + let price_info_object_3 = take_shared(&scenario); + let price_info_object_4 = take_shared(&scenario); + + // Create vector of price info objects (Iota objects with key ability and living in global store), + // which contain the price feeds we want to update. Note that these can be passed into + // update_price_feeds in any order! + //let price_info_object_vec = vector[price_info_object_1, price_info_object_2, price_info_object_3, price_info_object_4]; + verified_vaas = get_verified_test_vaas(&worm_state, &clock); + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let vaa_1 = vector::pop_back(&mut verified_vaas); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + // Create authenticated price infos + let vec = create_price_infos_hot_potato( + &pyth_state, + vector[vaa_1], + &clock + ); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + vec = update_single_price_feed( + &pyth_state, + vec, + &mut price_info_object_1, + test_coins, + &clock + ); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + hot_potato_vector::destroy(vec); + + vector::destroy_empty(verified_vaas); + + return_shared(price_info_object_1); + return_shared(price_info_object_2); + return_shared(price_info_object_3); + return_shared(price_info_object_4); + + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } + + + #[test] + fun test_update_cache(){ + let (scenario, test_coins, clock) = setup_test(500, 23, x"5d1f252d5de865279b00c84bce362774c2804294ed53299bc4a0389a5defef92", data_sources_for_test_vaa(), BATCH_ATTESTATION_TEST_INITIAL_GUARDIANS, DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + + let verified_vaas = get_verified_test_vaas(&worm_state, &clock); + + // Update cache is called by create_price_feeds. + pyth::create_price_feeds( + &mut pyth_state, + verified_vaas, + &clock, + ctx(&mut scenario) + ); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let price_info_object_1 = take_shared(&scenario); + let price_info_object_2 = take_shared(&scenario); + let price_info_object_3 = take_shared(&scenario); + let price_info_object_4 = take_shared(&scenario); + + // These updates are price infos that correspond to the ones in TEST_VAAS. + let updates = get_mock_price_infos(); + let price_info_object_vec = vector[ + price_info_object_1, + price_info_object_2, + price_info_object_3, + price_info_object_4 + ]; + + // Check that TEST_VAAS was indeed used to instantiate the price feeds correctly, + // by confirming that the info in updates is contained in price_info_object_vec. + check_price_feeds_cached(&updates, &price_info_object_vec); + + price_info_object_4 = vector::pop_back(&mut price_info_object_vec); + price_info_object_3 = vector::pop_back(&mut price_info_object_vec); + price_info_object_2 = vector::pop_back(&mut price_info_object_vec); + price_info_object_1 = vector::pop_back(&mut price_info_object_vec); + vector::destroy_empty(price_info_object_vec); + + return_shared(price_info_object_1); + return_shared(price_info_object_2); + return_shared(price_info_object_3); + return_shared(price_info_object_4); + coin::burn_for_testing(test_coins); + + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } + + #[test] + fun test_update_cache_old_update() { + use pyth::i64::Self; + use pyth::price::Self; + + let (scenario, test_coins, clock) = setup_test(500, 23, x"5d1f252d5de865279b00c84bce362774c2804294ed53299bc4a0389a5defef92", data_sources_for_test_vaa(), BATCH_ATTESTATION_TEST_INITIAL_GUARDIANS, DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let (pyth_state, worm_state) = take_wormhole_and_pyth_states(&scenario); + let verified_vaas = get_verified_test_vaas(&worm_state, &clock); + + pyth::create_price_feeds( + &mut pyth_state, + verified_vaas, + &clock, + ctx(&mut scenario) + ); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + let price_info_object_1 = take_shared(&scenario); + let price_info_object_2 = take_shared(&scenario); + let price_info_object_3 = take_shared(&scenario); + let price_info_object_4 = take_shared(&scenario); + + // Hardcode the price identifier, price, and ema_price for price_info_object_1, because + // it's easier than unwrapping price_info_object_1 and getting the quantities via getters. + let timestamp = 1663680740; + let price_identifier = price_identifier::from_byte_vec(x"c6c75c89f14810ec1c54c03ab8f1864a4c4032791f05747f560faec380a695d1"); + let price = price::new(i64::new(1557, false), 7, i64::new(5, true), timestamp); + let ema_price = price::new(i64::new(1500, false), 3, i64::new(5, true), timestamp); + + // Attempt to update the price with an update older than the current cached one. + let old_price = price::new(i64::new(1243, true), 9802, i64::new(6, false), timestamp - 200); + let old_ema_price = price::new(i64::new(8976, true), 234, i64::new(897, false), timestamp - 200); + let old_update = price_info::new_price_info( + 1257278600, + 1690226180, + price_feed::new( + price_identifier, + old_price, + old_ema_price, + ) + ); + let latest_only = pyth::state::create_latest_only_for_test(); + pyth::update_cache(latest_only, &old_update, &mut price_info_object_1, &clock); + + let current_price_info = price_info::get_price_info_from_price_info_object(&price_info_object_1); + let current_price_feed = price_info::get_price_feed(¤t_price_info); + let current_price = price_feed::get_price(current_price_feed); + let current_ema_price = price_feed::get_ema_price(current_price_feed); + + // Confirm that no price update occurred when we tried to update cache with an + // outdated update: old_update. + assert!(current_price == price, 1); + assert!(current_ema_price == ema_price, 1); + + test_scenario::next_tx(&mut scenario, DEPLOYER); + + // Update the cache with a fresh update. + let fresh_price = price::new(i64::new(5243, true), 2, i64::new(3, false), timestamp + 200); + let fresh_ema_price = price::new(i64::new(8976, true), 21, i64::new(32, false), timestamp + 200); + let fresh_update = price_info::new_price_info( + 1257278600, + 1690226180, + price_feed::new( + price_identifier, + fresh_price, + fresh_ema_price, + ) + ); + + let latest_only = pyth::state::create_latest_only_for_test(); + pyth::update_cache(latest_only, &fresh_update, &mut price_info_object_1, &clock); + + // Confirm that the Pyth cached price got updated to fresh_price. + let current_price_info = price_info::get_price_info_from_price_info_object(&price_info_object_1); + let current_price_feed = price_info::get_price_feed(¤t_price_info); + let current_price = price_feed::get_price(current_price_feed); + let current_ema_price = price_feed::get_ema_price(current_price_feed); + + assert!(current_price==fresh_price, 0); + assert!(current_ema_price==fresh_ema_price, 0); + + return_shared(price_info_object_1); + return_shared(price_info_object_2); + return_shared(price_info_object_3); + return_shared(price_info_object_4); + + coin::burn_for_testing(test_coins); + cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); + test_scenario::end(scenario); + } + + // pyth accumulator tests (included in this file instead of pyth_accumulator.move to avoid dependency cycle - as we need pyth_tests::setup_test) + #[test] + fun test_parse_and_verify_accumulator_updates(){ + use iota::test_scenario::{Self, take_shared, return_shared}; + use iota::transfer::{Self}; + + let (scenario, coins, clock) = setup_test(500, 23, ACCUMULATOR_TESTS_EMITTER_ADDRESS, vector[], ACCUMULATOR_TESTS_INITIAL_GUARDIANS, 50, 0); + let worm_state = take_shared(&scenario); + test_scenario::next_tx(&mut scenario, @0x123); + + let verified_vaa = get_verified_vaa_from_accumulator_message(&worm_state, TEST_ACCUMULATOR_3_MSGS, &clock); + + let cur = cursor::new(TEST_ACCUMULATOR_3_MSGS); + + let price_info_updates = accumulator::parse_and_verify_accumulator_message(&mut cur, vaa::take_payload(verified_vaa), &clock); + + let expected_price_infos = accumulator_test_3_to_price_info(0); + let num_updates = vector::length(&price_info_updates); + let i = 0; + while (i < num_updates){ + assert!(price_feeds_equal(vector::borrow(&price_info_updates, i), vector::borrow(&expected_price_infos, i)), 0); + i = i + 1; + }; + + // clean-up + cursor::take_rest(cur); + transfer::public_transfer(coins, @0x1234); + clock::destroy_for_testing(clock); + return_shared(worm_state); + test_scenario::end(scenario); + } + + #[test] + fun test_parse_and_verify_accumulator_updates_with_extra_bytes_at_end_of_message(){ + use iota::test_scenario::{Self, take_shared, return_shared}; + use iota::transfer::{Self}; + + let (scenario, coins, clock) = setup_test(500, 23, ACCUMULATOR_TESTS_EMITTER_ADDRESS, vector[], ACCUMULATOR_TESTS_INITIAL_GUARDIANS, 50, 0); + let worm_state = take_shared(&scenario); + test_scenario::next_tx(&mut scenario, @0x123); + + let verified_vaa = get_verified_vaa_from_accumulator_message(&worm_state, TEST_ACCUMULATOR_3_MSGS, &clock); + + // append some extra garbage bytes at the end of the accumulator message, and make sure + // that parse_and_verify_accumulator_message does not error out + let test_accumulator_3_msgs_modified = TEST_ACCUMULATOR_3_MSGS; + vector::append(&mut test_accumulator_3_msgs_modified, x"1234123412341234"); + + let cur = cursor::new(TEST_ACCUMULATOR_3_MSGS); + + let price_info_updates = accumulator::parse_and_verify_accumulator_message(&mut cur, vaa::take_payload(verified_vaa), &clock); + + let expected_price_infos = accumulator_test_3_to_price_info(0); + let num_updates = vector::length(&price_info_updates); + let i = 0; + while (i < num_updates){ + assert!(price_feeds_equal(vector::borrow(&price_info_updates, i), vector::borrow(&expected_price_infos, i)), 0); + i = i + 1; + }; + + // clean-up + cursor::take_rest(cur); + transfer::public_transfer(coins, @0x1234); + clock::destroy_for_testing(clock); + return_shared(worm_state); + test_scenario::end(scenario); + } + + fun price_feeds_equal(p1: &PriceInfo, p2: &PriceInfo): bool{ + price_info::get_price_feed(p1)== price_info::get_price_feed(p2) + } + + // helper functions for setting up tests + + // accumulator_test_3_to_price_info gets the data encoded within TEST_ACCUMULATOR_3_MSGS + fun accumulator_test_3_to_price_info(offset: u64): vector { + use pyth::i64::{Self}; + use pyth::price::{Self}; + let i = 0; + let feed_ids = vector[x"b10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6", + x"6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af", + x"31ecc21a745e3968a04e9570e4425bc18fa8019c68028196b546d1669c200c68"]; + let expected: vector = vector[]; + while (i < 3) { + vector::push_back(&mut expected, price_info::new_price_info( + 1663680747, + 1663074349, + price_feed::new( + price_identifier::from_byte_vec( + *vector::borrow(&feed_ids, i) + ), + price::new( + i64::new(100 + i + offset, false), + 50 + i + offset, + i64::new(9 + i + offset, false), + 1687276660 + i + offset + ), + price::new( + i64::new(99 + i + offset, false), + 52 + i + offset, + i64::new(9 + i + offset, false), + 1687276660 + i + offset + ), + ), + )); + i = i + 1; + }; + return expected + } + + // accumulator_test_1_to_price_info gets the data encoded within TEST_ACCUMULATOR_SINGLE_FEED + fun accumulator_test_1_to_price_info(): PriceInfo { + use pyth::i64::{Self}; + use pyth::price::{Self}; + price_info::new_price_info( + 1663680747, + 1663074349, + price_feed::new( + price_identifier::from_byte_vec( + x"b10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6" + ), + price::new( + i64::new(6887568746747646632, false), + 13092246197863718329, + i64::new(1559537863, false), + 1687276661 + ), + price::new( + i64::new(4772242609775910581, false), + 358129956189946877, + i64::new(1559537863, false), + 1687276661 + ), + ), + ) + } + + public fun cleanup_worm_state_pyth_state_and_clock(worm_state: WormState, pyth_state: PythState, clock: Clock){ + return_shared(worm_state); + return_shared(pyth_state); + clock::destroy_for_testing(clock); + } + + public fun take_wormhole_and_pyth_states(scenario: &Scenario): (PythState, WormState){ + (take_shared(scenario), take_shared(scenario)) + } +} diff --git a/target_chains/iota/contracts/sources/pyth_accumulator.move b/target_chains/iota/contracts/sources/pyth_accumulator.move new file mode 100644 index 0000000000..e00da563f0 --- /dev/null +++ b/target_chains/iota/contracts/sources/pyth_accumulator.move @@ -0,0 +1,123 @@ +module pyth::accumulator { + use std::vector::{Self}; + use iota::clock::{Clock, Self}; + use wormhole::bytes20::{Self, Bytes20}; + use wormhole::cursor::{Self, Cursor}; + use pyth::deserialize::{Self}; + use pyth::price_identifier::{Self}; + use pyth::price_info::{Self, PriceInfo}; + use pyth::price_feed::{Self}; + use pyth::merkle_tree::{Self}; + + const PRICE_FEED_MESSAGE_TYPE: u8 = 0; + const E_INVALID_UPDATE_DATA: u64 = 245; + const E_INVALID_PROOF: u64 = 345; + const E_INVALID_WORMHOLE_MESSAGE: u64 = 454; + const E_INVALID_ACCUMULATOR_PAYLOAD: u64 = 554; + const E_INVALID_ACCUMULATOR_HEADER: u64 = 657; + + const ACCUMULATOR_UPDATE_WORMHOLE_VERIFICATION_MAGIC: u32 = 1096111958; + const PYTHNET_ACCUMULATOR_UPDATE_MAGIC: u64 = 1347305813; + + const MINIMUM_SUPPORTED_MINOR_VERSION: u8 = 0; + const MAJOR_VERSION: u8 = 1; + + friend pyth::pyth; + #[test_only] + friend pyth::pyth_tests; + + // parse_and_verify_accumulator_message verifies that the price updates encoded in the + // accumulator message (accessed via cursor) belong to the merkle tree defined by the merkle root encoded in + // vaa_payload. + public(friend) fun parse_and_verify_accumulator_message(cursor: &mut Cursor, vaa_payload: vector, clock: &Clock): vector { + let header = deserialize::deserialize_u32(cursor); + + if ((header as u64) != PYTHNET_ACCUMULATOR_UPDATE_MAGIC) { + abort E_INVALID_ACCUMULATOR_HEADER + }; + + let major = deserialize::deserialize_u8(cursor); + assert!(major == MAJOR_VERSION, E_INVALID_ACCUMULATOR_PAYLOAD); + + let minor = deserialize::deserialize_u8(cursor); + assert!(minor >= MINIMUM_SUPPORTED_MINOR_VERSION, E_INVALID_ACCUMULATOR_PAYLOAD); + + let trailing_size = deserialize::deserialize_u8(cursor); + deserialize::deserialize_vector(cursor, (trailing_size as u64)); + + let proof_type = deserialize::deserialize_u8(cursor); + assert!(proof_type == 0, E_INVALID_ACCUMULATOR_PAYLOAD); + + // Ignore the vaa in the accumulator message because presumably it has already been verified + // and passed to this function as input. + let vaa_size = deserialize::deserialize_u16(cursor); + deserialize::deserialize_vector(cursor, (vaa_size as u64)); + + let merkle_root_hash = parse_accumulator_merkle_root_from_vaa_payload(vaa_payload); + parse_and_verify_accumulator_updates(cursor, merkle_root_hash, clock) + } + + // parse_accumulator_merkle_root_from_vaa_payload takes in some VAA bytes, verifies that the vaa + // corresponds to a merkle update, and finally returns the merkle root. + // Note: this function is adapted from the Aptos Pyth accumulator + fun parse_accumulator_merkle_root_from_vaa_payload(message: vector): Bytes20 { + let msg_payload_cursor = cursor::new(message); + let payload_type = deserialize::deserialize_u32(&mut msg_payload_cursor); + assert!(payload_type == ACCUMULATOR_UPDATE_WORMHOLE_VERIFICATION_MAGIC, E_INVALID_WORMHOLE_MESSAGE); + let wh_message_payload_type = deserialize::deserialize_u8(&mut msg_payload_cursor); + assert!(wh_message_payload_type == 0, E_INVALID_WORMHOLE_MESSAGE); // Merkle variant + let _merkle_root_slot = deserialize::deserialize_u64(&mut msg_payload_cursor); + let _merkle_root_ring_size = deserialize::deserialize_u32(&mut msg_payload_cursor); + let merkle_root_hash = deserialize::deserialize_vector(&mut msg_payload_cursor, 20); + cursor::take_rest(msg_payload_cursor); + bytes20::new(merkle_root_hash) + } + + // Note: this parsing function is adapted from the Aptos Pyth parse_price_feed_message function + fun parse_price_feed_message(message_cur: &mut Cursor, clock: &Clock): PriceInfo { + let message_type = deserialize::deserialize_u8(message_cur); + + assert!(message_type == PRICE_FEED_MESSAGE_TYPE, E_INVALID_UPDATE_DATA); + let price_identifier = price_identifier::from_byte_vec(deserialize::deserialize_vector(message_cur, 32)); + let price = deserialize::deserialize_i64(message_cur); + let conf = deserialize::deserialize_u64(message_cur); + let expo = deserialize::deserialize_i32(message_cur); + let publish_time = deserialize::deserialize_u64(message_cur); + let _prev_publish_time = deserialize::deserialize_i64(message_cur); + let ema_price = deserialize::deserialize_i64(message_cur); + let ema_conf = deserialize::deserialize_u64(message_cur); + let price_info = price_info::new_price_info( + clock::timestamp_ms(clock) / 1000, // not used anywhere kept for backward compatibility + clock::timestamp_ms(clock) / 1000, + price_feed::new( + price_identifier, + pyth::price::new(price, conf, expo, publish_time), + pyth::price::new(ema_price, ema_conf, expo, publish_time), + ) + ); + price_info + } + + // parse_and_verify_accumulator_updates takes as input a merkle root and cursor over the encoded update message (containing encoded + // leafs and merkle proofs), iterates over each leaf/proof pair and verifies it is part of the tree, and finally outputs the set of + // decoded and authenticated PriceInfos. + fun parse_and_verify_accumulator_updates(cursor: &mut Cursor, merkle_root: Bytes20, clock: &Clock): vector { + let update_size = deserialize::deserialize_u8(cursor); + let price_info_updates: vector = vector[]; + while (update_size > 0) { + let message_size = deserialize::deserialize_u16(cursor); + let message = deserialize::deserialize_vector(cursor, (message_size as u64)); //should be safe to go from u16 to u16 + let message_cur = cursor::new(message); + let price_info = parse_price_feed_message(&mut message_cur, clock); + cursor::take_rest(message_cur); + + vector::push_back(&mut price_info_updates, price_info); + + // isProofValid pops the next merkle proof from the front of cursor and checks if it proves that message is part of the + // merkle tree defined by merkle_root + assert!(merkle_tree::is_proof_valid(cursor, merkle_root, message), E_INVALID_PROOF); + update_size = update_size - 1; + }; + price_info_updates + } +} diff --git a/target_chains/iota/contracts/sources/set.move b/target_chains/iota/contracts/sources/set.move new file mode 100644 index 0000000000..f6d76186be --- /dev/null +++ b/target_chains/iota/contracts/sources/set.move @@ -0,0 +1,46 @@ +/// A set data structure. +module pyth::set { + use iota::table::{Self, Table}; + use iota::tx_context::{TxContext}; + use std::vector; + + /// Empty struct. Used as the value type in mappings to encode a set + struct Unit has store, copy, drop {} + + /// A set containing elements of type `A` with support for membership + /// checking. + struct Set has store { + keys: vector, + elems: Table + } + + /// Create a new Set. + public fun new(ctx: &mut TxContext): Set { + Set { + keys: vector::empty(), + elems: table::new(ctx), + } + } + + /// Add a new element to the set. + /// Aborts if the element already exists + public fun add(set: &mut Set, key: A) { + table::add(&mut set.elems, key, Unit {}); + vector::push_back(&mut set.keys, key); + } + + /// Returns true iff `set` contains an entry for `key`. + public fun contains(set: &Set, key: A): bool { + table::contains(&set.elems, key) + } + + /// Removes all elements from the set + public fun empty(set: &mut Set) { + while (!vector::is_empty(&set.keys)) { + table::remove(&mut set.elems, vector::pop_back(&mut set.keys)); + } + } + + // TODO: destroy_empty, but this is tricky because std::table doesn't + // have this functionality. +} diff --git a/target_chains/iota/contracts/sources/setup.move b/target_chains/iota/contracts/sources/setup.move new file mode 100644 index 0000000000..04eaba1bfe --- /dev/null +++ b/target_chains/iota/contracts/sources/setup.move @@ -0,0 +1,75 @@ +module pyth::setup { + use iota::object::{Self, UID}; + use iota::package::{Self, UpgradeCap}; + use iota::transfer::{Self}; + use iota::tx_context::{Self, TxContext}; + + use pyth::state::{Self}; + use pyth::data_source::{DataSource}; + + friend pyth::pyth; + #[test_only] + friend pyth::pyth_tests; + + /// Capability created at `init`, which will be destroyed once + /// `init_and_share_state` is called. This ensures only the deployer can + /// create the shared `State`. + struct DeployerCap has key, store { + id: UID + } + + fun init(ctx: &mut TxContext) { + transfer::public_transfer( + DeployerCap { + id: object::new(ctx) + }, + tx_context::sender(ctx) + ); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(ctx); + + // This will be created and sent to the transaction sender + // automatically when the contract is published. + transfer::public_transfer( + iota::package::test_publish(object::id_from_address(@pyth), ctx), + tx_context::sender(ctx) + ); + } + + #[allow(lint(share_owned))] + /// Only the owner of the `DeployerCap` can call this method. This + /// method destroys the capability and shares the `State` object. + public(friend) fun init_and_share_state( + deployer: DeployerCap, + upgrade_cap: UpgradeCap, + stale_price_threshold: u64, + base_update_fee: u64, + governance_data_source: DataSource, + sources: vector, + ctx: &mut TxContext + ) { + wormhole::package_utils::assert_package_upgrade_cap( + &upgrade_cap, + package::compatible_policy(), + 1 + ); + + // Destroy deployer cap. + let DeployerCap { id } = deployer; + object::delete(id); + + // Share new state. + transfer::public_share_object( + state::new( + upgrade_cap, + sources, + governance_data_source, + stale_price_threshold, + base_update_fee, + ctx + )); + } +} diff --git a/target_chains/iota/contracts/sources/state.move b/target_chains/iota/contracts/sources/state.move new file mode 100644 index 0000000000..3dcf6e62b5 --- /dev/null +++ b/target_chains/iota/contracts/sources/state.move @@ -0,0 +1,404 @@ +module pyth::state { + use std::vector; + use iota::object::{Self, UID, ID}; + use iota::tx_context::{Self, TxContext}; + use iota::package::{UpgradeCap, UpgradeTicket, UpgradeReceipt}; + + use pyth::data_source::{Self, DataSource}; + use pyth::price_info::{Self}; + use pyth::price_identifier::{Self, PriceIdentifier}; + use pyth::version_control::{Self}; + + use wormhole::consumed_vaas::{Self, ConsumedVAAs}; + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::package_utils::{Self}; + use wormhole::external_address::{ExternalAddress}; + + friend pyth::pyth; + #[test_only] + friend pyth::pyth_tests; + friend pyth::governance_action; + friend pyth::set_update_fee; + friend pyth::set_stale_price_threshold; + friend pyth::set_data_sources; + friend pyth::governance; + friend pyth::set_governance_data_source; + friend pyth::migrate; + friend pyth::contract_upgrade; + friend pyth::set_fee_recipient; + friend pyth::setup; + + /// Build digest does not agree with current implementation. + const E_INVALID_BUILD_DIGEST: u64 = 0; + + /// Capability reflecting that the current build version is used to invoke + /// state methods. + struct LatestOnly has drop {} + + #[test_only] + public fun create_latest_only_for_test():LatestOnly { + LatestOnly{} + } + + struct State has key, store { + id: UID, + governance_data_source: DataSource, + stale_price_threshold: u64, + base_update_fee: u64, + fee_recipient_address: address, + last_executed_governance_sequence: u64, + consumed_vaas: ConsumedVAAs, + + // Upgrade capability. + upgrade_cap: UpgradeCap + } + + public(friend) fun new( + upgrade_cap: UpgradeCap, + sources: vector, + governance_data_source: DataSource, + stale_price_threshold: u64, + base_update_fee: u64, + ctx: &mut TxContext + ): State { + let uid = object::new(ctx); + + // Create a set that contains all registered data sources and + // attach it to uid as a dynamic field to minimize the + // size of State. + data_source::new_data_source_registry(&mut uid, ctx); + + // Create a table that tracks the object IDs of price feeds and + // attach it to the uid as a dynamic object field to minimize the + // size of State. + price_info::new_price_info_registry(&mut uid, ctx); + + while (!vector::is_empty(&sources)) { + data_source::add(&mut uid, vector::pop_back(&mut sources)); + }; + + let consumed_vaas = consumed_vaas::new(ctx); + + // Initialize package info. This will be used for emitting information + // of successful migrations. + package_utils::init_package_info( + &mut uid, + version_control::current_version(), + &upgrade_cap + ); + + State { + id: uid, + upgrade_cap, + governance_data_source, + stale_price_threshold, + fee_recipient_address: tx_context::sender(ctx), + base_update_fee, + consumed_vaas, + last_executed_governance_sequence: 0 + } + } + + //////////////////////////////////////////////////////////////////////////// + // + // Simple Getters + // + // These methods do not require `LatestOnly` for access. Anyone is free to + // access these values. + // + //////////////////////////////////////////////////////////////////////////// + + public fun get_stale_price_threshold_secs(s: &State): u64 { + s.stale_price_threshold + } + + public fun get_base_update_fee(s: &State): u64 { + s.base_update_fee + } + + public fun get_fee_recipient(s: &State): address { + s.fee_recipient_address + } + + public fun is_valid_data_source(s: &State, data_source: DataSource): bool { + data_source::contains(&s.id, data_source) + } + + public fun is_valid_governance_data_source(s: &State, source: DataSource): bool { + s.governance_data_source == source + } + + public fun price_feed_object_exists(s: &State, p: PriceIdentifier): bool { + price_info::contains(&s.id, p) + } + + /// Retrieve governance chain ID, which is governance's emitter chain ID. + public fun governance_data_source(self: &State): DataSource { + self.governance_data_source + } + + public fun get_last_executed_governance_sequence(self: &State): u64{ + return self.last_executed_governance_sequence + } + + /// Retrieve governance module name. + public fun governance_module(): Bytes32 { + bytes32::new( + x"0000000000000000000000000000000000000000000000000000000000000001" + ) + } + + /// Retrieve governance chain ID, which is governance's emitter chain ID. + public fun governance_chain(self: &State): u16 { + let governance_data_source = governance_data_source(self); + (data_source::emitter_chain(&governance_data_source) as u16) + } + + /// Retrieve governance emitter address. + public fun governance_contract(self: &State): ExternalAddress { + let governance_data_source = governance_data_source(self); + data_source::emitter_address(&governance_data_source) + } + + public fun get_price_info_object_id(self: &State, price_identifier_bytes: vector): ID { + let price_identifier = price_identifier::from_byte_vec(price_identifier_bytes); + price_info::get_id(&self.id, price_identifier) + } + + //////////////////////////////////////////////////////////////////////////// + // + // Privileged `State` Access + // + // This section of methods require a `LatestOnly`, which can only be created + // within the Wormhole package. This capability allows special access to + // the `State` object. + // + // NOTE: A lot of these methods are still marked as `(friend)` as a safety + // precaution. When a package is upgraded, friend modifiers can be + // removed. + // + //////////////////////////////////////////////////////////////////////////// + + /// Obtain a capability to interact with `State` methods. This method checks + /// that we are running the current build. + /// + /// NOTE: This method allows caching the current version check so we avoid + /// multiple checks to dynamic fields. + public(friend) fun assert_latest_only(self: &State): LatestOnly { + package_utils::assert_version( + &self.id, + version_control::current_version() + ); + + LatestOnly {} + } + + public(friend) fun set_fee_recipient( + _: &LatestOnly, + self: &mut State, + addr: address + ) { + self.fee_recipient_address = addr; + } + + /// Store `VAA` hash as a way to claim a VAA. This method prevents a VAA + /// from being replayed. For Wormhole, the only VAAs that it cares about + /// being replayed are its governance actions. + public(friend) fun borrow_mut_consumed_vaas( + _: &LatestOnly, + self: &mut State + ): &mut ConsumedVAAs { + borrow_mut_consumed_vaas_unchecked(self) + } + + /// Store `VAA` hash as a way to claim a VAA. This method prevents a VAA + /// from being replayed. For Wormhole, the only VAAs that it cares about + /// being replayed are its governance actions. + /// + /// NOTE: This method does not require `LatestOnly`. Only methods in the + /// `upgrade_contract` module requires this to be unprotected to prevent + /// a corrupted upgraded contract from bricking upgradability. + public(friend) fun borrow_mut_consumed_vaas_unchecked( + self: &mut State + ): &mut ConsumedVAAs { + &mut self.consumed_vaas + } + + public(friend) fun current_package(_: &LatestOnly, self: &State): ID { + package_utils::current_package(&self.id) + } + + public(friend) fun set_data_sources(_: &LatestOnly, s: &mut State, new_sources: vector) { + // Empty the existing table of data sources registered in state. + data_source::empty(&mut s.id); + // Add the new data sources to the dynamic field registry. + while (!vector::is_empty(&new_sources)) { + data_source::add(&mut s.id, vector::pop_back(&mut new_sources)); + }; + } + + public(friend) fun register_price_info_object(_: &LatestOnly, s: &mut State, price_identifier: PriceIdentifier, id: ID) { + price_info::add(&mut s.id, price_identifier, id); + } + + public(friend) fun set_governance_data_source(_: &LatestOnly, s: &mut State, source: DataSource) { + s.governance_data_source = source; + } + + public(friend) fun set_last_executed_governance_sequence(_: &LatestOnly, s: &mut State, sequence: u64) { + s.last_executed_governance_sequence = sequence; + } + + // We have an unchecked version of set_last_executed_governance_sequence, because in the governance contract + // upgrade code path, no LatestOnly is created (for example, see authorize_upgrade and commit_upgrade in + // governance/contract_upgrade.move) + public(friend) fun set_last_executed_governance_sequence_unchecked(s: &mut State, sequence: u64) { + s.last_executed_governance_sequence = sequence; + } + + public(friend) fun set_base_update_fee(_: &LatestOnly, s: &mut State, fee: u64) { + s.base_update_fee = fee; + } + + public(friend) fun set_stale_price_threshold_secs(_: &LatestOnly, s: &mut State, threshold_secs: u64) { + s.stale_price_threshold = threshold_secs; + } + + //////////////////////////////////////////////////////////////////////////// + // + // Upgradability + // + // A special space that controls upgrade logic. These methods are invoked + // via the `upgrade_contract` module. + // + // Also in this section is managing contract migrations, which uses the + // `migrate` module to officially roll state access to the latest build. + // Only those methods that require `LatestOnly` will be affected by an + // upgrade. + // + //////////////////////////////////////////////////////////////////////////// + + /// Issue an `UpgradeTicket` for the upgrade. + /// + /// NOTE: The Iota VM performs a check that this method is executed from the + /// latest published package. If someone were to try to execute this using + /// a stale build, the transaction will revert with `PackageUpgradeError`, + /// specifically `PackageIDDoesNotMatch`. + public(friend) fun authorize_upgrade( + self: &mut State, + package_digest: Bytes32 + ): UpgradeTicket { + let cap = &mut self.upgrade_cap; + package_utils::authorize_upgrade(&mut self.id, cap, package_digest) + } + + /// Finalize the upgrade that ran to produce the given `receipt`. + /// + /// NOTE: The Iota VM performs a check that this method is executed from the + /// latest published package. If someone were to try to execute this using + /// a stale build, the transaction will revert with `PackageUpgradeError`, + /// specifically `PackageIDDoesNotMatch`. + public(friend) fun commit_upgrade( + self: &mut State, + receipt: UpgradeReceipt + ): (ID, ID) { + let cap = &mut self.upgrade_cap; + package_utils::commit_upgrade(&mut self.id, cap, receipt) + } + + /// Method executed by the `migrate` module to roll access from one package + /// to another. This method will be called from the upgraded package. + public(friend) fun migrate_version(self: &mut State) { + package_utils::migrate_version( + &mut self.id, + version_control::previous_version(), + version_control::current_version() + ); + } + + /// As a part of the migration, we verify that the upgrade contract VAA's + /// encoded package digest used in `migrate` equals the one used to conduct + /// the upgrade. + public(friend) fun assert_authorized_digest( + _: &LatestOnly, + self: &State, + digest: Bytes32 + ) { + let authorized = package_utils::authorized_digest(&self.id); + assert!(digest == authorized, E_INVALID_BUILD_DIGEST); + } + + //////////////////////////////////////////////////////////////////////////// + // + // Special State Interaction via Migrate + // + // A VERY special space that manipulates `State` via calling `migrate`. + // + // PLEASE KEEP ANY METHODS HERE AS FRIENDS. We want the ability to remove + // these for future builds. + // + //////////////////////////////////////////////////////////////////////////// + + public(friend) fun migrate__v__0_1_1(self: &mut State) { + // We need to add dynamic fields via the new package utils method. These + // fields do not exist in the previous build (0.1.0). + // See `state::new` above. + + // Initialize package info. This will be used for emitting information + // of successful migrations. + let upgrade_cap = &self.upgrade_cap; + package_utils::init_package_info( + &mut self.id, + version_control::current_version(), + upgrade_cap, + ); + } + + #[test_only] + /// Bloody hack. + public fun reverse_migrate__v__0_1_0(self: &mut State) { + package_utils::remove_package_info(&mut self.id); + + // Add back in old dynamic field(s)... + + // Add dummy hash since this is the first time the package is published. + iota::dynamic_field::add(&mut self.id, CurrentDigest {}, bytes32::from_bytes(b"new build")); + } + + #[test_only] + public fun register_price_info_object_for_test(self: &mut State, price_identifier: PriceIdentifier, id: ID) { + price_info::add(&mut self.id, price_identifier, id); + } + + #[test_only] + public fun new_state_for_test( + upgrade_cap: UpgradeCap, + governance_data_source: DataSource, + stale_price_threshold: u64, + base_update_fee: u64, + ctx: &mut TxContext + ): State { + State { + id: object::new(ctx), + upgrade_cap, + governance_data_source, + stale_price_threshold, + base_update_fee, + fee_recipient_address: tx_context::sender(ctx), + last_executed_governance_sequence: 0, + consumed_vaas: consumed_vaas::new(ctx), + } + } + + //////////////////////////////////////////////////////////////////////////// + // + // Deprecated + // + // Dumping grounds for old structs and methods. These things should not + // be used in future builds. + // + //////////////////////////////////////////////////////////////////////////// + + struct CurrentDigest has store, drop, copy {} + +} diff --git a/target_chains/iota/contracts/sources/version_control.move b/target_chains/iota/contracts/sources/version_control.move new file mode 100644 index 0000000000..ab5b3446d8 --- /dev/null +++ b/target_chains/iota/contracts/sources/version_control.move @@ -0,0 +1,81 @@ +// SPDX-License-Identifier: Apache 2 + +/// Note: this module is adapted from Wormhole's version_control.move module. +/// +/// This module implements dynamic field keys as empty structs. These keys are +/// used to determine the latest version for this build. If the current version +/// is not this build's, then paths through the `state` module will abort. +/// +/// See `pyth::state` and `wormhole::package_utils` for more info. +module pyth::version_control { + //////////////////////////////////////////////////////////////////////////// + // + // Hard-coded Version Control + // + // Before upgrading, please set the types for `current_version` and + // `previous_version` to match the correct types (current being the latest + // version reflecting this build). + // + //////////////////////////////////////////////////////////////////////////// + + public(friend) fun current_version(): V__0_1_2 { + V__0_1_2 {} + } + + public(friend) fun previous_version(): V__0_1_1 { + V__0_1_1 {} + } + + //////////////////////////////////////////////////////////////////////////// + // + // Change Log + // + // Please write release notes as doc strings for each version struct. These + // notes will be our attempt at tracking upgrades. Wish us luck. + // + //////////////////////////////////////////////////////////////////////////// + + /// RELEASE NOTES + /// + /// - Gas optimizations on merkle tree verifications + struct V__0_1_2 has store, drop, copy {} + + /// RELEASE NOTES + /// + /// - Refactor state to use package management via + /// `wormhole::package_utils`. + /// - Add `MigrateComplete` event in `migrate`. + /// + /// Also added `migrate__v__0_1_1` in `wormhole::state`, which is + /// meant to perform a one-time `State` modification via `migrate`. + struct V__0_1_1 has store, drop, copy {} + + // Dummy. + struct V__DUMMY has store, drop, copy {} + + //////////////////////////////////////////////////////////////////////////// + // + // Implementation and Test-Only Methods + // + //////////////////////////////////////////////////////////////////////////// + + friend pyth::state; + + #[test_only] + public fun dummy(): V__DUMMY { + V__DUMMY {} + } + + #[test_only] + struct V__MIGRATED has store, drop, copy {} + + #[test_only] + public fun next_version(): V__MIGRATED { + V__MIGRATED {} + } + + #[test_only] + public fun previous_version_test_only(): V__0_1_1 { + previous_version() + } +} diff --git a/target_chains/iota/iota-patch-libs.sh b/target_chains/iota/iota-patch-libs.sh new file mode 100644 index 0000000000..c4079d6073 --- /dev/null +++ b/target_chains/iota/iota-patch-libs.sh @@ -0,0 +1,36 @@ +#!/bin/bash + +set -euo pipefail + +# This script patches the SUI code to be compatible with IOTA. IOTA is a fork +# of SUI but is not compatible with SUI. You'd need to run this script for +# deploying Pyth contracts and updating the vendored libs. +# +# Note: Do not commit the patched Pyth code to the repo. + +# Check if exactly one argument (base path) is provided +if [ $# -ne 1 ]; then + echo "Usage: $0 " + exit 1 +fi + +# Detect OS to determine correct sed syntax +if sed --version >/dev/null 2>&1; then + SED_CMD=sed +else + if ! command -v gsed >/dev/null 2>&1; then + echo "Error: GNU sed (gsed) is required for macOS/BSD. Install core-utils via Homebrew." + exit 1 + fi + SED_CMD=gsed +fi + +# Use find to get all .move files recursively and process them +find "$1" -type f -name "*.move" | while read -r file; do + echo "Processing: $file" + $SED_CMD -i -e 's/\bSUI\b/IOTA/g' \ + -e 's/\bSui\b/Iota/g' \ + -e 's/\bsui\b/iota/g' "$file" +done + +echo "Replacements complete." diff --git a/target_chains/iota/sdk/js-iota/.eslintrc.js b/target_chains/iota/sdk/js-iota/.eslintrc.js new file mode 100644 index 0000000000..8fa976bb6e --- /dev/null +++ b/target_chains/iota/sdk/js-iota/.eslintrc.js @@ -0,0 +1,9 @@ +module.exports = { + root: true, + parser: "@typescript-eslint/parser", + plugins: ["@typescript-eslint"], + extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"], + rules: { + "@typescript-eslint/no-explicit-any": "off", + }, +}; diff --git a/target_chains/iota/sdk/js-iota/.gitignore b/target_chains/iota/sdk/js-iota/.gitignore new file mode 100644 index 0000000000..a65b41774a --- /dev/null +++ b/target_chains/iota/sdk/js-iota/.gitignore @@ -0,0 +1 @@ +lib diff --git a/target_chains/iota/sdk/js-iota/README.md b/target_chains/iota/sdk/js-iota/README.md new file mode 100644 index 0000000000..45de93b3c7 --- /dev/null +++ b/target_chains/iota/sdk/js-iota/README.md @@ -0,0 +1,155 @@ +# Pyth IOTA JS SDK + +[Pyth](https://pyth.network/) provides real-time pricing data in a variety of asset classes, including cryptocurrency, equities, FX and commodities. +This library allows you to use these real-time prices on the [IOTA network](https://www.iota.org/). + +## Installation + +### npm + +``` +$ npm install --save @pythnetwork/pyth-iota-js +``` + +### Yarn + +``` +$ yarn add @pythnetwork/pyth-iota-js +``` + +## Quickstart + +Pyth stores prices off-chain to minimize gas fees, which allows us to offer a wider selection of products and faster update times. +See [On-Demand Updates](https://docs.pyth.network/documentation/pythnet-price-feeds/on-demand) for more information about this approach. +Typically, to use Pyth prices on chain, +they must be fetched from an off-chain Hermes instance. The `IotaPriceServiceConnection` class can be used to interact with these services, +providing a way to fetch these prices directly in your code. The following example wraps an existing RPC provider and shows how to obtain +Pyth prices and submit them to the network: + +```typescript +const connection = new IotaPriceServiceConnection( + "https://hermes.pyth.network" +); // See Hermes endpoints section below for other endpoints + +const priceIds = [ + // You can find the ids of prices at https://pyth.network/developers/price-feed-ids + "0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43", // BTC/USD price id + "0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace", // ETH/USD price id +]; + +// In order to use Pyth prices in your protocol you need to submit the price update data to Pyth contract in your target +// chain. `getPriceUpdateData` creates the update data which can be submitted to your contract. + +const priceUpdateData = await connection.getPriceFeedsUpdateData(priceIds); +``` + +## On-chain prices + +### **_Important Note for Integrators_** + +Your IOTA Move module **should NOT** have a hard-coded call to `pyth::update_single_price_feed`. In other words, the Iota Pyth `pyth::update_single_price_feed` entry point should never be called by a contract, instead it should be called directly from client code (e.g. Typescript or Rust). + +This is because when a IOTA contract is [upgraded](https://docs.iota.org/developer/iota-101/move-overview/package-upgrades/upgrade), the new address is different from the original. If your module has a hard-coded call to `pyth::update_single_price_feed` living at a fixed call-site, it may eventually get bricked due to the way Pyth upgrades are implemented. (We only allows users to interact with the most recent package version for security reasons). + +Therefore, you should build a [Iota programmable transaction](https://docs.iota.org/ts-sdk/typescript/transaction-building/basics) that first updates the price by calling `pyth::update_single_price_feed` at the latest call-site from the client-side and then call a function in your contract that invokes `pyth::get_price` on the `PriceInfoObject` to get the recently updated price. +You can use `IotaPythClient` to build such transactions. + +### Example + +```ts +import { IotaPythClient } from "@pythnetwork/pyth-iota-js"; +import { Transaction } from "@iota/iota-sdk/transactions"; +import { IotaClient } from "@iota/iota-sdk/client"; + +const priceUpdateData = await connection.getPriceFeedsUpdateData(priceIds); // see quickstart section + + +// It is either injected from browser or instantiated in backend via some private key +const wallet: SignerWithProvider = getWallet(); +// Get the state ids of the Pyth and Wormhole contracts from +// https://docs.pyth.network/documentation/pythnet-price-feeds/sui +const wormholeStateId = " 0xFILL_ME"; +const pythStateId = "0xFILL_ME"; + +const provider = new IotaClient({ url: "https://fill-iota-endpoint" }); +const client = new IotaPythClient(wallet.provider, pythStateId, wormholeStateId); +const tx = new Transaction(); +const priceInfoObjectIds = await client.updatePriceFeeds(tx, priceFeedUpdateData, priceIds); + +tx.moveCall({ + target: `YOUR_PACKAGE::YOUR_MODULE::use_pyth_for_defi`, + arguments: [ + ..., // other arguments needed for your contract + tx.object(pythStateId), + tx.object(priceInfoObjectIds[0]), + ], +}); + +const result = await provider.signAndExecuteTransaction({ + signer: wallet, + transaction: tx, + options: { + showEffects: true, + showEvents: true, + }, +}); +``` + +Now in your contract you can consume the price by calling `pyth::get_price` or other utility functions on the `PriceInfoObject`. + +### CLI Example + +[This example](./src/examples/IotaRelay.ts) shows how to update prices on an IOTA network. It does the following: + +1. Fetches update data from Hermes for the given price feeds. +2. Calls the Pyth IOTA contract with the update data. + +You can run this example with `npm run example-relay`. A full command that updates prices on IOTA testnet looks like: + +```bash +export IOTA_KEY=YOUR_PRIV_KEY; +npm run example-relay -- --feed-id "ff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace" \ +--price-service "https://hermes.pyth.network" \ +--full-node "https://api.testnet.iota.cafe" \ +--pyth-state-id "0x68dda579251917b3db28e35c4df495c6e664ccc085ede867a9b773c8ebedc2c1" \ +--wormhole-state-id "0x8bc490f69520a97ca1b3de864c96aa2265a0cf5d90f5f3f016b2eddf0cf2af2b" +``` + +## Off-chain prices + +Many applications additionally need to display Pyth prices off-chain, for example, in their frontend application. +The `IotaPriceServiceConnection` provides two different ways to fetch the current Pyth price. +The code blocks below assume that the `connection` and `priceIds` objects have been initialized as shown above. +The first method is a single-shot query: + +```typescript +// `getLatestPriceFeeds` returns a `PriceFeed` for each price id. It contains all information about a price and has +// utility functions to get the current and exponentially-weighted moving average price, and other functionality. +const priceFeeds = await connection.getLatestPriceFeeds(priceIds); +// Get the price if it is not older than 60 seconds from the current time. +console.log(priceFeeds[0].getPriceNoOlderThan(60)); // Price { conf: '1234', expo: -8, price: '12345678' } +// Get the exponentially-weighted moving average price if it is not older than 60 seconds from the current time. +console.log(priceFeeds[1].getEmaPriceNoOlderThan(60)); +``` + +The object also supports a streaming websocket connection that allows you to subscribe to every new price update for a given feed. +This method is useful if you want to show continuously updating real-time prices in your frontend: + +```typescript +// Subscribe to the price feeds given by `priceId`. The callback will be invoked every time the requested feed +// gets a price update. +connection.subscribePriceFeedUpdates(priceIds, (priceFeed) => { + console.log( + `Received update for ${priceFeed.id}: ${priceFeed.getPriceNoOlderThan(60)}` + ); +}); + +// When using the subscription, make sure to close the websocket upon termination to finish the process gracefully. +setTimeout(() => { + connection.closeWebSocket(); +}, 60000); +``` + +## Hermes endpoints + +You can find the list of Hermes public endpoints [here](https://docs.pyth.network/documentation/pythnet-price-feeds/hermes#public-endpoints). diff --git a/target_chains/iota/sdk/js-iota/jest.config.js b/target_chains/iota/sdk/js-iota/jest.config.js new file mode 100644 index 0000000000..21a1e973ab --- /dev/null +++ b/target_chains/iota/sdk/js-iota/jest.config.js @@ -0,0 +1,5 @@ +/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */ +module.exports = { + preset: "ts-jest", + testEnvironment: "node", +}; diff --git a/target_chains/iota/sdk/js-iota/package.json b/target_chains/iota/sdk/js-iota/package.json new file mode 100644 index 0000000000..b3622e3949 --- /dev/null +++ b/target_chains/iota/sdk/js-iota/package.json @@ -0,0 +1,59 @@ +{ + "name": "@pythnetwork/pyth-iota-js", + "version": "2.1.0", + "description": "Pyth Network IOTA Utilities", + "homepage": "https://pyth.network", + "author": { + "name": "Pyth Data Association" + }, + "main": "lib/index.js", + "types": "lib/index.d.ts", + "files": [ + "lib/**/*" + ], + "repository": { + "type": "git", + "url": "https://github.com/pyth-network/pyth-crosschain", + "directory": "target_chains/sui/sdk/js-iota" + }, + "publishConfig": { + "access": "public" + }, + "scripts": { + "build": "tsc", + "example-relay": "pnpm run build && node lib/examples/SuiRelay.js", + "format": "prettier --write \"src/**/*.ts\"", + "test:lint": "eslint src/", + "prepublishOnly": "pnpm run build && pnpm test:lint", + "preversion": "pnpm run test:lint", + "version": "pnpm run format && git add -A src" + }, + "keywords": [ + "pyth", + "oracle", + "iota" + ], + "license": "Apache-2.0", + "devDependencies": { + "@truffle/hdwallet-provider": "^2.1.5", + "@types/ethereum-protocol": "^1.0.2", + "@types/jest": "^29.4.0", + "@types/node": "^18.11.18", + "@types/web3-provider-engine": "^14.0.1", + "@types/yargs": "^17.0.20", + "@typescript-eslint/eslint-plugin": "^6.0.0", + "@typescript-eslint/parser": "^6.0.0", + "eslint": "^8.14.0", + "jest": "^29.4.1", + "prettier": "^2.6.2", + "ts-jest": "^29.0.5", + "typescript": "^5.3.3", + "web3": "^1.8.2", + "yargs": "^17.0.20" + }, + "dependencies": { + "@iota/iota-sdk": "^0.5.0", + "@pythnetwork/price-service-client": "workspace:*", + "buffer": "^6.0.3" + } +} diff --git a/target_chains/iota/sdk/js-iota/src/IotaPriceServiceConnection.ts b/target_chains/iota/sdk/js-iota/src/IotaPriceServiceConnection.ts new file mode 100644 index 0000000000..c7292c2e60 --- /dev/null +++ b/target_chains/iota/sdk/js-iota/src/IotaPriceServiceConnection.ts @@ -0,0 +1,21 @@ +import { + PriceServiceConnection, + HexString, +} from "@pythnetwork/price-service-client"; +import { Buffer } from "buffer"; + +export class IotaPriceServiceConnection extends PriceServiceConnection { + /** + * Gets price update data (either batch price attestation VAAs or accumulator messages, depending on the chosen endpoint), which then + * can be submitted to the Pyth contract to update the prices. This will throw an axios error if there is a network problem or + * the price service returns a non-ok response (e.g: Invalid price ids) + * + * @param priceIds Array of hex-encoded price ids. + * @returns Array of buffers containing the price update data. + */ + async getPriceFeedsUpdateData(priceIds: HexString[]): Promise { + // Fetch the latest price feed update VAAs from the price service + const latestVaas = await this.getLatestVaas(priceIds); + return latestVaas.map((vaa) => Buffer.from(vaa, "base64")); + } +} diff --git a/target_chains/iota/sdk/js-iota/src/client.ts b/target_chains/iota/sdk/js-iota/src/client.ts new file mode 100644 index 0000000000..86797d695c --- /dev/null +++ b/target_chains/iota/sdk/js-iota/src/client.ts @@ -0,0 +1,304 @@ +import { IotaClient } from "@iota/iota-sdk/client"; +import { IOTA_CLOCK_OBJECT_ID } from "@iota/iota-sdk/utils"; +import { Transaction } from "@iota/iota-sdk/transactions"; +import { bcs } from "@iota/iota-sdk/bcs"; +import { HexString } from "@pythnetwork/price-service-client"; +import { Buffer } from "buffer"; + +const MAX_ARGUMENT_SIZE = 16 * 1024; +export type ObjectId = string; + +export class IotaPythClient { + private pythPackageId: ObjectId | undefined; + private wormholePackageId: ObjectId | undefined; + private priceTableInfo: { id: ObjectId; fieldType: ObjectId } | undefined; + private priceFeedObjectIdCache: Map = new Map(); + private baseUpdateFee: number | undefined; + constructor( + public provider: IotaClient, + public pythStateId: ObjectId, + public wormholeStateId: ObjectId + ) { + this.pythPackageId = undefined; + this.wormholePackageId = undefined; + } + + async getBaseUpdateFee(): Promise { + if (this.baseUpdateFee === undefined) { + const result = await this.provider.getObject({ + id: this.pythStateId, + options: { showContent: true }, + }); + if ( + !result.data || + !result.data.content || + result.data.content.dataType !== "moveObject" + ) + throw new Error("Unable to fetch pyth state object"); + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-ignore + this.baseUpdateFee = result.data.content.fields.base_update_fee as number; + } + + return this.baseUpdateFee; + } + + /** + * getPackageId returns the latest package id that the object belongs to. Use this to + * fetch the latest package id for a given object id and handle package upgrades automatically. + * @param objectId + * @returns package id + */ + async getPackageId(objectId: ObjectId): Promise { + const state = await this.provider + .getObject({ + id: objectId, + options: { + showContent: true, + }, + }) + .then((result) => { + if (result.data?.content?.dataType == "moveObject") { + return result.data.content.fields; + } + console.log(result.data?.content); + + throw new Error(`Cannot fetch package id for object ${objectId}`); + }); + + if ("upgrade_cap" in state) { + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-ignore + return state.upgrade_cap.fields.package; + } + + throw new Error("upgrade_cap not found"); + } + + /** + * Adds the commands for calling wormhole and verifying the vaas and returns the verified vaas. + * @param vaas array of vaas to verify + * @param tx transaction block to add commands to + */ + async verifyVaas(vaas: Buffer[], tx: Transaction) { + const wormholePackageId = await this.getWormholePackageId(); + const verifiedVaas = []; + for (const vaa of vaas) { + const [verifiedVaa] = tx.moveCall({ + target: `${wormholePackageId}::vaa::parse_and_verify`, + arguments: [ + tx.object(this.wormholeStateId), + tx.pure( + bcs + .vector(bcs.U8) + .serialize(Array.from(vaa), { + maxSize: MAX_ARGUMENT_SIZE, + }) + .toBytes() + ), + tx.object(IOTA_CLOCK_OBJECT_ID), + ], + }); + verifiedVaas.push(verifiedVaa); + } + return verifiedVaas; + } + + /** + * Adds the necessary commands for updating the pyth price feeds to the transaction block. + * @param tx transaction block to add commands to + * @param updates array of price feed updates received from the price service + * @param feedIds array of feed ids to update (in hex format) + */ + async updatePriceFeeds( + tx: Transaction, + updates: Buffer[], + feedIds: HexString[] + ): Promise { + const packageId = await this.getPythPackageId(); + + let priceUpdatesHotPotato; + if (updates.length > 1) { + throw new Error( + "SDK does not support sending multiple accumulator messages in a single transaction" + ); + } + const vaa = this.extractVaaBytesFromAccumulatorMessage(updates[0]); + const verifiedVaas = await this.verifyVaas([vaa], tx); + [priceUpdatesHotPotato] = tx.moveCall({ + target: `${packageId}::pyth::create_authenticated_price_infos_using_accumulator`, + arguments: [ + tx.object(this.pythStateId), + tx.pure( + bcs + .vector(bcs.U8) + .serialize(Array.from(updates[0]), { + maxSize: MAX_ARGUMENT_SIZE, + }) + .toBytes() + ), + verifiedVaas[0], + tx.object(IOTA_CLOCK_OBJECT_ID), + ], + }); + + const priceInfoObjects: ObjectId[] = []; + const baseUpdateFee = await this.getBaseUpdateFee(); + const coins = tx.splitCoins( + tx.gas, + feedIds.map(() => tx.pure.u64(baseUpdateFee)) + ); + let coinId = 0; + for (const feedId of feedIds) { + const priceInfoObjectId = await this.getPriceFeedObjectId(feedId); + if (!priceInfoObjectId) { + throw new Error( + `Price feed ${feedId} not found, please create it first` + ); + } + priceInfoObjects.push(priceInfoObjectId); + [priceUpdatesHotPotato] = tx.moveCall({ + target: `${packageId}::pyth::update_single_price_feed`, + arguments: [ + tx.object(this.pythStateId), + priceUpdatesHotPotato, + tx.object(priceInfoObjectId), + coins[coinId], + tx.object(IOTA_CLOCK_OBJECT_ID), + ], + }); + coinId++; + } + tx.moveCall({ + target: `${packageId}::hot_potato_vector::destroy`, + arguments: [priceUpdatesHotPotato], + typeArguments: [`${packageId}::price_info::PriceInfo`], + }); + return priceInfoObjects; + } + async createPriceFeed(tx: Transaction, updates: Buffer[]) { + const packageId = await this.getPythPackageId(); + if (updates.length > 1) { + throw new Error( + "SDK does not support sending multiple accumulator messages in a single transaction" + ); + } + const vaa = this.extractVaaBytesFromAccumulatorMessage(updates[0]); + const verifiedVaas = await this.verifyVaas([vaa], tx); + tx.moveCall({ + target: `${packageId}::pyth::create_price_feeds_using_accumulator`, + arguments: [ + tx.object(this.pythStateId), + tx.pure( + bcs + .vector(bcs.U8) + .serialize(Array.from(updates[0]), { + maxSize: MAX_ARGUMENT_SIZE, + }) + .toBytes() + ), + verifiedVaas[0], + tx.object(IOTA_CLOCK_OBJECT_ID), + ], + }); + } + + /** + * Get the packageId for the wormhole package if not already cached + */ + async getWormholePackageId() { + if (!this.wormholePackageId) { + this.wormholePackageId = await this.getPackageId(this.wormholeStateId); + } + return this.wormholePackageId; + } + + /** + * Get the packageId for the pyth package if not already cached + */ + async getPythPackageId() { + if (!this.pythPackageId) { + this.pythPackageId = await this.getPackageId(this.pythStateId); + } + return this.pythPackageId; + } + + /** + * Get the priceFeedObjectId for a given feedId if not already cached + * @param feedId + */ + async getPriceFeedObjectId(feedId: HexString): Promise { + const normalizedFeedId = feedId.replace("0x", ""); + if (!this.priceFeedObjectIdCache.has(normalizedFeedId)) { + const { id: tableId, fieldType } = await this.getPriceTableInfo(); + const result = await this.provider.getDynamicFieldObject({ + parentId: tableId, + name: { + type: `${fieldType}::price_identifier::PriceIdentifier`, + value: { + bytes: Array.from(Buffer.from(normalizedFeedId, "hex")), + }, + }, + }); + if (!result.data || !result.data.content) { + return undefined; + } + if (result.data.content.dataType !== "moveObject") { + throw new Error("Price feed type mismatch"); + } + this.priceFeedObjectIdCache.set( + normalizedFeedId, + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-ignore + result.data.content.fields.value + ); + } + return this.priceFeedObjectIdCache.get(normalizedFeedId); + } + + /** + * Fetches the price table object id for the current state id if not cached + * @returns price table object id + */ + async getPriceTableInfo(): Promise<{ id: ObjectId; fieldType: ObjectId }> { + if (this.priceTableInfo === undefined) { + const result = await this.provider.getDynamicFieldObject({ + parentId: this.pythStateId, + name: { + type: "vector", + value: "price_info", + }, + }); + if (!result.data || !result.data.type) { + throw new Error( + "Price Table not found, contract may not be initialized" + ); + } + let type = result.data.type.replace("0x2::table::Table<", ""); + type = type.replace( + "::price_identifier::PriceIdentifier, 0x2::object::ID>", + "" + ); + this.priceTableInfo = { id: result.data.objectId, fieldType: type }; + } + return this.priceTableInfo; + } + + /** + * Obtains the vaa bytes embedded in an accumulator message. + * @param accumulatorMessage - the accumulator price update message + * @returns vaa bytes as a uint8 array + */ + extractVaaBytesFromAccumulatorMessage(accumulatorMessage: Buffer): Buffer { + // the first 6 bytes in the accumulator message encode the header, major, and minor bytes + // we ignore them, since we are only interested in the VAA bytes + const trailingPayloadSize = accumulatorMessage.readUint8(6); + const vaaSizeOffset = + 7 + // header bytes (header(4) + major(1) + minor(1) + trailing payload size(1)) + trailingPayloadSize + // trailing payload (variable number of bytes) + 1; // proof_type (1 byte) + const vaaSize = accumulatorMessage.readUint16BE(vaaSizeOffset); + const vaaOffset = vaaSizeOffset + 2; + return accumulatorMessage.subarray(vaaOffset, vaaOffset + vaaSize); + } +} diff --git a/target_chains/iota/sdk/js-iota/src/examples/IotaRelay.ts b/target_chains/iota/sdk/js-iota/src/examples/IotaRelay.ts new file mode 100644 index 0000000000..c0c9ed13ab --- /dev/null +++ b/target_chains/iota/sdk/js-iota/src/examples/IotaRelay.ts @@ -0,0 +1,97 @@ +import yargs from "yargs"; +import { hideBin } from "yargs/helpers"; +import { IotaClient } from "@iota/iota-sdk/client"; +import { Transaction } from "@iota/iota-sdk/transactions"; +import { Ed25519Keypair } from "@iota/iota-sdk/keypairs/ed25519"; + +import { Buffer } from "buffer"; +import { IotaPythClient } from "../client"; +import { IotaPriceServiceConnection } from "../index"; + +const argvPromise = yargs(hideBin(process.argv)) + .option("feed-id", { + description: + "Price feed ids to update without the leading 0x (e.g f9c0172ba10dfa4d19088d94f5bf61d3b54d5bd7483a322a982e1373ee8ea31b). Can be provided multiple times for multiple feed updates", + type: "array", + demandOption: true, + }) + .option("hermes", { + description: "Endpoint URL for Hermes. e.g: https://hermes.pyth.network", + type: "string", + demandOption: true, + }) + .option("full-node", { + description: + "URL of the full IOTA node RPC endpoint. e.g: https://api.testnet.iota.cafe/", + type: "string", + demandOption: true, + }) + .option("pyth-state-id", { + description: "Pyth state object id.", + type: "string", + demandOption: true, + }) + .option("wormhole-state-id", { + description: "Wormhole state object id.", + type: "string", + demandOption: true, + }).argv; + +export function getProvider(url: string) { + return new IotaClient({ url }); +} +async function run() { + if (process.env.IOTA_KEY === undefined) { + throw new Error(`IOTA_KEY environment variable should be set.`); + } + + const argv = await argvPromise; + + // Fetch the latest price feed update data from the Price Service + const connection = new IotaPriceServiceConnection(argv["hermes"]); + const feeds = argv["feed-id"] as string[]; + + const provider = getProvider(argv["full-node"]); + const wormholeStateId = argv["wormhole-state-id"]; + const pythStateId = argv["pyth-state-id"]; + + const client = new IotaPythClient(provider, pythStateId, wormholeStateId); + const newFeeds = []; + const existingFeeds = []; + for (const feed of feeds) { + if ((await client.getPriceFeedObjectId(feed)) == undefined) { + newFeeds.push(feed); + } else { + existingFeeds.push(feed); + } + } + console.log({ + newFeeds, + existingFeeds, + }); + const tx = new Transaction(); + if (existingFeeds.length > 0) { + const updateData = await connection.getPriceFeedsUpdateData(existingFeeds); + await client.updatePriceFeeds(tx, updateData, existingFeeds); + } + if (newFeeds.length > 0) { + const updateData = await connection.getPriceFeedsUpdateData(newFeeds); + await client.createPriceFeed(tx, updateData); + } + + const wallet = Ed25519Keypair.fromSecretKey( + Buffer.from(process.env.IOTA_KEY, "hex") + ); + + const result = await provider.signAndExecuteTransaction({ + signer: wallet, + transaction: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); + console.dir(result, { depth: null }); +} + +run(); diff --git a/target_chains/iota/sdk/js-iota/src/index.ts b/target_chains/iota/sdk/js-iota/src/index.ts new file mode 100644 index 0000000000..6a67047575 --- /dev/null +++ b/target_chains/iota/sdk/js-iota/src/index.ts @@ -0,0 +1,11 @@ +export { IotaPriceServiceConnection } from "./IotaPriceServiceConnection"; +export { IotaPythClient } from "./client"; + +export { + DurationInMs, + HexString, + Price, + PriceFeed, + PriceServiceConnectionConfig, + UnixTimestamp, +} from "@pythnetwork/price-service-client"; diff --git a/target_chains/iota/sdk/js-iota/tsconfig.json b/target_chains/iota/sdk/js-iota/tsconfig.json new file mode 100644 index 0000000000..927049ab35 --- /dev/null +++ b/target_chains/iota/sdk/js-iota/tsconfig.json @@ -0,0 +1,14 @@ +{ + "extends": "../../../../tsconfig.base.json", + "compilerOptions": { + "target": "esnext", + "module": "commonjs", + "declaration": true, + "outDir": "./lib", + "rootDir": "src/", + "strict": true, + "esModuleInterop": true + }, + "include": ["src"], + "exclude": ["node_modules", "**/__tests__/*"] +} diff --git a/target_chains/iota/sdk/js/.eslintrc.js b/target_chains/iota/sdk/js/.eslintrc.js new file mode 100644 index 0000000000..8fa976bb6e --- /dev/null +++ b/target_chains/iota/sdk/js/.eslintrc.js @@ -0,0 +1,9 @@ +module.exports = { + root: true, + parser: "@typescript-eslint/parser", + plugins: ["@typescript-eslint"], + extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"], + rules: { + "@typescript-eslint/no-explicit-any": "off", + }, +}; diff --git a/target_chains/iota/sdk/js/.gitignore b/target_chains/iota/sdk/js/.gitignore new file mode 100644 index 0000000000..a65b41774a --- /dev/null +++ b/target_chains/iota/sdk/js/.gitignore @@ -0,0 +1 @@ +lib diff --git a/target_chains/iota/sdk/js/README.md b/target_chains/iota/sdk/js/README.md new file mode 100644 index 0000000000..d39cd67b8f --- /dev/null +++ b/target_chains/iota/sdk/js/README.md @@ -0,0 +1,154 @@ +# Pyth Sui JS SDK + +[Pyth](https://pyth.network/) provides real-time pricing data in a variety of asset classes, including cryptocurrency, equities, FX and commodities. This library allows you to use these real-time prices on the [Sui network](https://sui.io/). + +## Installation + +### npm + +``` +$ npm install --save @pythnetwork/pyth-sui-js +``` + +### Yarn + +``` +$ yarn add @pythnetwork/pyth-sui-js +``` + +## Quickstart + +Pyth stores prices off-chain to minimize gas fees, which allows us to offer a wider selection of products and faster update times. +See [On-Demand Updates](https://docs.pyth.network/documentation/pythnet-price-feeds/on-demand) for more information about this approach. +Typically, to use Pyth prices on chain, +they must be fetched from an off-chain Hermes instance. The `SuiPriceServiceConnection` class can be used to interact with these services, +providing a way to fetch these prices directly in your code. The following example wraps an existing RPC provider and shows how to obtain +Pyth prices and submit them to the network: + +```typescript +const connection = new SuiPriceServiceConnection( + "https://hermes-beta.pyth.network" +); // See Hermes endpoints section below for other endpoints + +const priceIds = [ + // You can find the ids of prices at https://pyth.network/developers/price-feed-ids#sui-testnet + "0xf9c0172ba10dfa4d19088d94f5bf61d3b54d5bd7483a322a982e1373ee8ea31b", // BTC/USD price id in testnet + "0xca80ba6dc32e08d06f1aa886011eed1d77c77be9eb761cc10d72b7d0a2fd57a6", // ETH/USD price id in testnet +]; + +// In order to use Pyth prices in your protocol you need to submit the price update data to Pyth contract in your target +// chain. `getPriceUpdateData` creates the update data which can be submitted to your contract. + +const priceUpdateData = await connection.getPriceFeedsUpdateData(priceIds); +``` + +## On-chain prices + +### **_Important Note for Integrators_** + +Your Sui Move module **should NOT** have a hard-coded call to `pyth::update_single_price_feed`. In other words, the Sui Pyth `pyth::update_single_price_feed` entry point should never be called by a contract, instead it should be called directly from client code (e.g. Typescript or Rust). + +This is because when a Sui contract is [upgraded](https://docs.sui.io/build/package-upgrades), the new address is different from the original. If your module has a hard-coded call to `pyth::update_single_price_feed` living at a fixed call-site, it may eventually get bricked due to the way Pyth upgrades are implemented. (We only allows users to interact with the most recent package version for security reasons). + +Therefore, you should build a [Sui programmable transaction](https://docs.sui.io/build/prog-trans-ts-sdk) that first updates the price by calling `pyth::update_single_price_feed` at the latest call-site from the client-side and then call a function in your contract that invokes `pyth::get_price` on the `PriceInfoObject` to get the recently updated price. +You can use `SuiPythClient` to build such transactions. + +### Example + +```ts +import { SuiPythClient } from "@pythnetwork/pyth-sui-js"; +import { Transaction } from "@mysten/sui/transactions"; +import { SuiClient } from "@mysten/sui/client"; + +const priceUpdateData = await connection.getPriceFeedsUpdateData(priceIds); // see quickstart section + + +// It is either injected from browser or instantiated in backend via some private key +const wallet: SignerWithProvider = getWallet(); +// Get the state ids of the Pyth and Wormhole contracts from +// https://docs.pyth.network/documentation/pythnet-price-feeds/sui +const wormholeStateId = " 0xFILL_ME"; +const pythStateId = "0xFILL_ME"; + +const provider = new SuiClient({ url: "https://fill-sui-endpoint" }); +const client = new SuiPythClient(wallet.provider, pythStateId, wormholeStateId); +const tx = new Transaction(); +const priceInfoObjectIds = await client.updatePriceFeeds(tx, priceFeedUpdateData, priceIds); + +tx.moveCall({ + target: `YOUR_PACKAGE::YOUR_MODULE::use_pyth_for_defi`, + arguments: [ + ..., // other arguments needed for your contract + tx.object(pythStateId), + tx.object(priceInfoObjectIds[0]), + ], +}); + +const result = await provider.signAndExecuteTransaction({ + signer: wallet, + transaction: tx, + options: { + showEffects: true, + showEvents: true, + }, +}); +``` + +Now in your contract you can consume the price by calling `pyth::get_price` or other utility functions on the `PriceInfoObject`. + +### CLI Example + +[This example](./src/examples/SuiRelay.ts) shows how to update prices on an Sui network. It does the following: + +1. Fetches update data from Hermes for the given price feeds. +2. Calls the Pyth Sui contract with the update data. + +You can run this example with `npm run example-relay`. A full command that updates prices on Sui testnet looks like: + +```bash +export SUI_KEY=YOUR_PRIV_KEY; +npm run example-relay -- --feed-id "5a035d5440f5c163069af66062bac6c79377bf88396fa27e6067bfca8096d280" \ +--price-service "https://hermes-beta.pyth.network" \ +--full-node "https://fullnode.testnet.sui.io:443" \ +--pyth-state-id "0xd3e79c2c083b934e78b3bd58a490ec6b092561954da6e7322e1e2b3c8abfddc0" \ +--wormhole-state-id "0x31358d198147da50db32eda2562951d53973a0c0ad5ed738e9b17d88b213d790" +``` + +## Off-chain prices + +Many applications additionally need to display Pyth prices off-chain, for example, in their frontend application. +The `SuiPriceServiceConnection` provides two different ways to fetch the current Pyth price. +The code blocks below assume that the `connection` and `priceIds` objects have been initialized as shown above. +The first method is a single-shot query: + +```typescript +// `getLatestPriceFeeds` returns a `PriceFeed` for each price id. It contains all information about a price and has +// utility functions to get the current and exponentially-weighted moving average price, and other functionality. +const priceFeeds = await connection.getLatestPriceFeeds(priceIds); +// Get the price if it is not older than 60 seconds from the current time. +console.log(priceFeeds[0].getPriceNoOlderThan(60)); // Price { conf: '1234', expo: -8, price: '12345678' } +// Get the exponentially-weighted moving average price if it is not older than 60 seconds from the current time. +console.log(priceFeeds[1].getEmaPriceNoOlderThan(60)); +``` + +The object also supports a streaming websocket connection that allows you to subscribe to every new price update for a given feed. +This method is useful if you want to show continuously updating real-time prices in your frontend: + +```typescript +// Subscribe to the price feeds given by `priceId`. The callback will be invoked every time the requested feed +// gets a price update. +connection.subscribePriceFeedUpdates(priceIds, (priceFeed) => { + console.log( + `Received update for ${priceFeed.id}: ${priceFeed.getPriceNoOlderThan(60)}` + ); +}); + +// When using the subscription, make sure to close the websocket upon termination to finish the process gracefully. +setTimeout(() => { + connection.closeWebSocket(); +}, 60000); +``` + +## Hermes endpoints + +You can find the list of Hermes public endpoints [here](https://docs.pyth.network/documentation/pythnet-price-feeds/hermes#public-endpoints). diff --git a/target_chains/iota/sdk/js/jest.config.js b/target_chains/iota/sdk/js/jest.config.js new file mode 100644 index 0000000000..21a1e973ab --- /dev/null +++ b/target_chains/iota/sdk/js/jest.config.js @@ -0,0 +1,5 @@ +/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */ +module.exports = { + preset: "ts-jest", + testEnvironment: "node", +}; diff --git a/target_chains/iota/sdk/js/package.json b/target_chains/iota/sdk/js/package.json new file mode 100644 index 0000000000..d7674a5121 --- /dev/null +++ b/target_chains/iota/sdk/js/package.json @@ -0,0 +1,59 @@ +{ + "name": "@pythnetwork/pyth-sui-js", + "version": "2.1.0", + "description": "Pyth Network Sui Utilities", + "homepage": "https://pyth.network", + "author": { + "name": "Pyth Data Association" + }, + "main": "lib/index.js", + "types": "lib/index.d.ts", + "files": [ + "lib/**/*" + ], + "repository": { + "type": "git", + "url": "https://github.com/pyth-network/pyth-crosschain", + "directory": "target_chains/sui/sdk/js" + }, + "publishConfig": { + "access": "public" + }, + "scripts": { + "build": "tsc", + "example-relay": "pnpm run build && node lib/examples/SuiRelay.js", + "format": "prettier --write \"src/**/*.ts\"", + "test:lint": "eslint src/ --max-warnings 0", + "prepublishOnly": "pnpm run build && pnpm test:lint", + "preversion": "pnpm run test:lint", + "version": "pnpm run format && git add -A src" + }, + "keywords": [ + "pyth", + "oracle", + "sui" + ], + "license": "Apache-2.0", + "devDependencies": { + "@truffle/hdwallet-provider": "^2.1.5", + "@types/ethereum-protocol": "^1.0.2", + "@types/jest": "^29.4.0", + "@types/node": "^18.11.18", + "@types/web3-provider-engine": "^14.0.1", + "@types/yargs": "^17.0.20", + "@typescript-eslint/eslint-plugin": "^6.0.0", + "@typescript-eslint/parser": "^6.0.0", + "eslint": "^8.14.0", + "jest": "^29.4.1", + "prettier": "^2.6.2", + "ts-jest": "^29.0.5", + "typescript": "^5.3.3", + "web3": "^1.8.2", + "yargs": "^17.0.20" + }, + "dependencies": { + "@mysten/sui": "^1.3.0", + "@pythnetwork/price-service-client": "workspace:*", + "buffer": "^6.0.3" + } +} diff --git a/target_chains/iota/sdk/js/src/SuiPriceServiceConnection.ts b/target_chains/iota/sdk/js/src/SuiPriceServiceConnection.ts new file mode 100644 index 0000000000..6d520cf3e3 --- /dev/null +++ b/target_chains/iota/sdk/js/src/SuiPriceServiceConnection.ts @@ -0,0 +1,21 @@ +import { + PriceServiceConnection, + HexString, +} from "@pythnetwork/price-service-client"; +import { Buffer } from "buffer"; + +export class SuiPriceServiceConnection extends PriceServiceConnection { + /** + * Gets price update data (either batch price attestation VAAs or accumulator messages, depending on the chosen endpoint), which then + * can be submitted to the Pyth contract to update the prices. This will throw an axios error if there is a network problem or + * the price service returns a non-ok response (e.g: Invalid price ids) + * + * @param priceIds Array of hex-encoded price ids. + * @returns Array of buffers containing the price update data. + */ + async getPriceFeedsUpdateData(priceIds: HexString[]): Promise { + // Fetch the latest price feed update VAAs from the price service + const latestVaas = await this.getLatestVaas(priceIds); + return latestVaas.map((vaa) => Buffer.from(vaa, "base64")); + } +} diff --git a/target_chains/iota/sdk/js/src/client.ts b/target_chains/iota/sdk/js/src/client.ts new file mode 100644 index 0000000000..f65e2e21aa --- /dev/null +++ b/target_chains/iota/sdk/js/src/client.ts @@ -0,0 +1,304 @@ +import { SuiClient } from "@mysten/sui/client"; +import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils"; +import { Transaction } from "@mysten/sui/transactions"; +import { bcs } from "@mysten/sui/bcs"; +import { HexString } from "@pythnetwork/price-service-client"; +import { Buffer } from "buffer"; + +const MAX_ARGUMENT_SIZE = 16 * 1024; +export type ObjectId = string; + +export class SuiPythClient { + private pythPackageId: ObjectId | undefined; + private wormholePackageId: ObjectId | undefined; + private priceTableInfo: { id: ObjectId; fieldType: ObjectId } | undefined; + private priceFeedObjectIdCache: Map = new Map(); + private baseUpdateFee: number | undefined; + constructor( + public provider: SuiClient, + public pythStateId: ObjectId, + public wormholeStateId: ObjectId + ) { + this.pythPackageId = undefined; + this.wormholePackageId = undefined; + } + + async getBaseUpdateFee(): Promise { + if (this.baseUpdateFee === undefined) { + const result = await this.provider.getObject({ + id: this.pythStateId, + options: { showContent: true }, + }); + if ( + !result.data || + !result.data.content || + result.data.content.dataType !== "moveObject" + ) + throw new Error("Unable to fetch pyth state object"); + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-ignore + this.baseUpdateFee = result.data.content.fields.base_update_fee as number; + } + + return this.baseUpdateFee; + } + + /** + * getPackageId returns the latest package id that the object belongs to. Use this to + * fetch the latest package id for a given object id and handle package upgrades automatically. + * @param objectId + * @returns package id + */ + async getPackageId(objectId: ObjectId): Promise { + const state = await this.provider + .getObject({ + id: objectId, + options: { + showContent: true, + }, + }) + .then((result) => { + if (result.data?.content?.dataType == "moveObject") { + return result.data.content.fields; + } + console.log(result.data?.content); + + throw new Error(`Cannot fetch package id for object ${objectId}`); + }); + + if ("upgrade_cap" in state) { + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-ignore + return state.upgrade_cap.fields.package; + } + + throw new Error("upgrade_cap not found"); + } + + /** + * Adds the commands for calling wormhole and verifying the vaas and returns the verified vaas. + * @param vaas array of vaas to verify + * @param tx transaction block to add commands to + */ + async verifyVaas(vaas: Buffer[], tx: Transaction) { + const wormholePackageId = await this.getWormholePackageId(); + const verifiedVaas = []; + for (const vaa of vaas) { + const [verifiedVaa] = tx.moveCall({ + target: `${wormholePackageId}::vaa::parse_and_verify`, + arguments: [ + tx.object(this.wormholeStateId), + tx.pure( + bcs + .vector(bcs.U8) + .serialize(Array.from(vaa), { + maxSize: MAX_ARGUMENT_SIZE, + }) + .toBytes() + ), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + verifiedVaas.push(verifiedVaa); + } + return verifiedVaas; + } + + /** + * Adds the necessary commands for updating the pyth price feeds to the transaction block. + * @param tx transaction block to add commands to + * @param updates array of price feed updates received from the price service + * @param feedIds array of feed ids to update (in hex format) + */ + async updatePriceFeeds( + tx: Transaction, + updates: Buffer[], + feedIds: HexString[] + ): Promise { + const packageId = await this.getPythPackageId(); + + let priceUpdatesHotPotato; + if (updates.length > 1) { + throw new Error( + "SDK does not support sending multiple accumulator messages in a single transaction" + ); + } + const vaa = this.extractVaaBytesFromAccumulatorMessage(updates[0]); + const verifiedVaas = await this.verifyVaas([vaa], tx); + [priceUpdatesHotPotato] = tx.moveCall({ + target: `${packageId}::pyth::create_authenticated_price_infos_using_accumulator`, + arguments: [ + tx.object(this.pythStateId), + tx.pure( + bcs + .vector(bcs.U8) + .serialize(Array.from(updates[0]), { + maxSize: MAX_ARGUMENT_SIZE, + }) + .toBytes() + ), + verifiedVaas[0], + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + const priceInfoObjects: ObjectId[] = []; + const baseUpdateFee = await this.getBaseUpdateFee(); + const coins = tx.splitCoins( + tx.gas, + feedIds.map(() => tx.pure.u64(baseUpdateFee)) + ); + let coinId = 0; + for (const feedId of feedIds) { + const priceInfoObjectId = await this.getPriceFeedObjectId(feedId); + if (!priceInfoObjectId) { + throw new Error( + `Price feed ${feedId} not found, please create it first` + ); + } + priceInfoObjects.push(priceInfoObjectId); + [priceUpdatesHotPotato] = tx.moveCall({ + target: `${packageId}::pyth::update_single_price_feed`, + arguments: [ + tx.object(this.pythStateId), + priceUpdatesHotPotato, + tx.object(priceInfoObjectId), + coins[coinId], + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + coinId++; + } + tx.moveCall({ + target: `${packageId}::hot_potato_vector::destroy`, + arguments: [priceUpdatesHotPotato], + typeArguments: [`${packageId}::price_info::PriceInfo`], + }); + return priceInfoObjects; + } + async createPriceFeed(tx: Transaction, updates: Buffer[]) { + const packageId = await this.getPythPackageId(); + if (updates.length > 1) { + throw new Error( + "SDK does not support sending multiple accumulator messages in a single transaction" + ); + } + const vaa = this.extractVaaBytesFromAccumulatorMessage(updates[0]); + const verifiedVaas = await this.verifyVaas([vaa], tx); + tx.moveCall({ + target: `${packageId}::pyth::create_price_feeds_using_accumulator`, + arguments: [ + tx.object(this.pythStateId), + tx.pure( + bcs + .vector(bcs.U8) + .serialize(Array.from(updates[0]), { + maxSize: MAX_ARGUMENT_SIZE, + }) + .toBytes() + ), + verifiedVaas[0], + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + } + + /** + * Get the packageId for the wormhole package if not already cached + */ + async getWormholePackageId() { + if (!this.wormholePackageId) { + this.wormholePackageId = await this.getPackageId(this.wormholeStateId); + } + return this.wormholePackageId; + } + + /** + * Get the packageId for the pyth package if not already cached + */ + async getPythPackageId() { + if (!this.pythPackageId) { + this.pythPackageId = await this.getPackageId(this.pythStateId); + } + return this.pythPackageId; + } + + /** + * Get the priceFeedObjectId for a given feedId if not already cached + * @param feedId + */ + async getPriceFeedObjectId(feedId: HexString): Promise { + const normalizedFeedId = feedId.replace("0x", ""); + if (!this.priceFeedObjectIdCache.has(normalizedFeedId)) { + const { id: tableId, fieldType } = await this.getPriceTableInfo(); + const result = await this.provider.getDynamicFieldObject({ + parentId: tableId, + name: { + type: `${fieldType}::price_identifier::PriceIdentifier`, + value: { + bytes: Array.from(Buffer.from(normalizedFeedId, "hex")), + }, + }, + }); + if (!result.data || !result.data.content) { + return undefined; + } + if (result.data.content.dataType !== "moveObject") { + throw new Error("Price feed type mismatch"); + } + this.priceFeedObjectIdCache.set( + normalizedFeedId, + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-ignore + result.data.content.fields.value + ); + } + return this.priceFeedObjectIdCache.get(normalizedFeedId); + } + + /** + * Fetches the price table object id for the current state id if not cached + * @returns price table object id + */ + async getPriceTableInfo(): Promise<{ id: ObjectId; fieldType: ObjectId }> { + if (this.priceTableInfo === undefined) { + const result = await this.provider.getDynamicFieldObject({ + parentId: this.pythStateId, + name: { + type: "vector", + value: "price_info", + }, + }); + if (!result.data || !result.data.type) { + throw new Error( + "Price Table not found, contract may not be initialized" + ); + } + let type = result.data.type.replace("0x2::table::Table<", ""); + type = type.replace( + "::price_identifier::PriceIdentifier, 0x2::object::ID>", + "" + ); + this.priceTableInfo = { id: result.data.objectId, fieldType: type }; + } + return this.priceTableInfo; + } + + /** + * Obtains the vaa bytes embedded in an accumulator message. + * @param accumulatorMessage - the accumulator price update message + * @returns vaa bytes as a uint8 array + */ + extractVaaBytesFromAccumulatorMessage(accumulatorMessage: Buffer): Buffer { + // the first 6 bytes in the accumulator message encode the header, major, and minor bytes + // we ignore them, since we are only interested in the VAA bytes + const trailingPayloadSize = accumulatorMessage.readUint8(6); + const vaaSizeOffset = + 7 + // header bytes (header(4) + major(1) + minor(1) + trailing payload size(1)) + trailingPayloadSize + // trailing payload (variable number of bytes) + 1; // proof_type (1 byte) + const vaaSize = accumulatorMessage.readUint16BE(vaaSizeOffset); + const vaaOffset = vaaSizeOffset + 2; + return accumulatorMessage.subarray(vaaOffset, vaaOffset + vaaSize); + } +} diff --git a/target_chains/iota/sdk/js/src/examples/SuiRelay.ts b/target_chains/iota/sdk/js/src/examples/SuiRelay.ts new file mode 100644 index 0000000000..cb40f4b1e5 --- /dev/null +++ b/target_chains/iota/sdk/js/src/examples/SuiRelay.ts @@ -0,0 +1,97 @@ +import yargs from "yargs"; +import { hideBin } from "yargs/helpers"; +import { SuiClient } from "@mysten/sui/client"; +import { Transaction } from "@mysten/sui/transactions"; +import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"; + +import { Buffer } from "buffer"; +import { SuiPythClient } from "../client"; +import { SuiPriceServiceConnection } from "../index"; + +const argvPromise = yargs(hideBin(process.argv)) + .option("feed-id", { + description: + "Price feed ids to update without the leading 0x (e.g f9c0172ba10dfa4d19088d94f5bf61d3b54d5bd7483a322a982e1373ee8ea31b). Can be provided multiple times for multiple feed updates", + type: "array", + demandOption: true, + }) + .option("hermes", { + description: "Endpoint URL for Hermes. e.g: https://hermes.pyth.network", + type: "string", + demandOption: true, + }) + .option("full-node", { + description: + "URL of the full Sui node RPC endpoint. e.g: https://fullnode.testnet.sui.io:443", + type: "string", + demandOption: true, + }) + .option("pyth-state-id", { + description: "Pyth state object id.", + type: "string", + demandOption: true, + }) + .option("wormhole-state-id", { + description: "Wormhole state object id.", + type: "string", + demandOption: true, + }).argv; + +export function getProvider(url: string) { + return new SuiClient({ url }); +} +async function run() { + if (process.env.SUI_KEY === undefined) { + throw new Error(`SUI_KEY environment variable should be set.`); + } + + const argv = await argvPromise; + + // Fetch the latest price feed update data from the Price Service + const connection = new SuiPriceServiceConnection(argv["hermes"]); + const feeds = argv["feed-id"] as string[]; + + const provider = getProvider(argv["full-node"]); + const wormholeStateId = argv["wormhole-state-id"]; + const pythStateId = argv["pyth-state-id"]; + + const client = new SuiPythClient(provider, pythStateId, wormholeStateId); + const newFeeds = []; + const existingFeeds = []; + for (const feed of feeds) { + if ((await client.getPriceFeedObjectId(feed)) == undefined) { + newFeeds.push(feed); + } else { + existingFeeds.push(feed); + } + } + console.log({ + newFeeds, + existingFeeds, + }); + const tx = new Transaction(); + if (existingFeeds.length > 0) { + const updateData = await connection.getPriceFeedsUpdateData(existingFeeds); + await client.updatePriceFeeds(tx, updateData, existingFeeds); + } + if (newFeeds.length > 0) { + const updateData = await connection.getPriceFeedsUpdateData(newFeeds); + await client.createPriceFeed(tx, updateData); + } + + const wallet = Ed25519Keypair.fromSecretKey( + Buffer.from(process.env.SUI_KEY, "hex") + ); + + const result = await provider.signAndExecuteTransaction({ + signer: wallet, + transaction: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); + console.dir(result, { depth: null }); +} + +run(); diff --git a/target_chains/iota/sdk/js/src/index.ts b/target_chains/iota/sdk/js/src/index.ts new file mode 100644 index 0000000000..f4cfecf948 --- /dev/null +++ b/target_chains/iota/sdk/js/src/index.ts @@ -0,0 +1,11 @@ +export { SuiPriceServiceConnection } from "./SuiPriceServiceConnection"; +export { SuiPythClient } from "./client"; + +export { + DurationInMs, + HexString, + Price, + PriceFeed, + PriceServiceConnectionConfig, + UnixTimestamp, +} from "@pythnetwork/price-service-client"; diff --git a/target_chains/iota/sdk/js/tsconfig.json b/target_chains/iota/sdk/js/tsconfig.json new file mode 100644 index 0000000000..927049ab35 --- /dev/null +++ b/target_chains/iota/sdk/js/tsconfig.json @@ -0,0 +1,14 @@ +{ + "extends": "../../../../tsconfig.base.json", + "compilerOptions": { + "target": "esnext", + "module": "commonjs", + "declaration": true, + "outDir": "./lib", + "rootDir": "src/", + "strict": true, + "esModuleInterop": true + }, + "include": ["src"], + "exclude": ["node_modules", "**/__tests__/*"] +} diff --git a/target_chains/iota/vendor/README.md b/target_chains/iota/vendor/README.md new file mode 100644 index 0000000000..589fb36c17 --- /dev/null +++ b/target_chains/iota/vendor/README.md @@ -0,0 +1,11 @@ +# Vendored dependencies for SUI contract + +This directory contains the wormhole dependencies used for deploying Pyth contracts on the chains that Wormhole is not +officially deployed on. For each network, a slightly different variant of the code should be used that has the +`CHAIN_ID` constant (in `wormhole/sources/state.move`) and `Move.toml` modified. Therefore, we are storing +each of them in a separate directory. + +The Wormhole contract is taken out of commit +[`e94c8ef4a810cae63d4e54811aa6a843b5fd9e65`](https://github.com/wormhole-foundation/wormhole/tree/e94c8ef4a810cae63d4e54811aa6a843b5fd9e65) +from the Wormhole repository. To update it, pull the latest version and copy it here and update the +README. diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/.gitignore b/target_chains/iota/vendor/wormhole_iota_testnet/.gitignore new file mode 100644 index 0000000000..6ddb4b0ac3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/.gitignore @@ -0,0 +1,2 @@ +deploy.out +sui.log.* diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/Docker.md b/target_chains/iota/vendor/wormhole_iota_testnet/Docker.md new file mode 100755 index 0000000000..97ff842f6d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/Docker.md @@ -0,0 +1,13 @@ +# first build the image + +cd ..; DOCKER_BUILDKIT=1 docker build --no-cache --progress plain -f sui/Dockerfile.base -t sui . + +# tag the image with the appropriate version + +docker tag sui:latest ghcr.io/wormhole-foundation/sui:1.19.1-mainnet + +# push to ghcr + +docker push ghcr.io/wormhole-foundation/sui:1.19.1-mainnet + +echo remember to update both Dockerfile and Dockerfile.export diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/Dockerfile b/target_chains/iota/vendor/wormhole_iota_testnet/Dockerfile new file mode 100644 index 0000000000..4bef3a3624 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/Dockerfile @@ -0,0 +1,33 @@ +FROM cli-gen AS cli-export +FROM const-gen AS const-export +FROM ghcr.io/wormhole-foundation/sui:1.19.1-mainnet@sha256:544a1b2aa5701fae25a19aed3c5e8c24e0caf7d1c9f511b6844d339a8f0b2a00 as sui + +# initial run +# COPY sui/devnet/genesis_config genesis_config +# RUN sui genesis -f --from-config genesis_config + +# subsequent runs after committing files from /root/.sui/sui_config/ +COPY sui/devnet/ /root/.sui/sui_config/ + +WORKDIR /tmp + +COPY sui/scripts/ scripts +COPY sui/wormhole/ wormhole +COPY sui/token_bridge/ token_bridge +COPY sui/examples/ examples +COPY sui/Makefile Makefile + +# Copy .env and CLI +COPY --from=const-export .env .env +COPY --from=cli-export clients/js /cli + +# Link `worm` +WORKDIR /cli + +RUN npm link + +FROM sui AS tests + +WORKDIR /tmp + +RUN --mount=type=cache,target=/root/.move,id=move_cache make test diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/Dockerfile.base b/target_chains/iota/vendor/wormhole_iota_testnet/Dockerfile.base new file mode 100644 index 0000000000..4c76dc016d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/Dockerfile.base @@ -0,0 +1,24 @@ +FROM rust:1.62@sha256:5777f201f507075309c4d2d1c1e8d8219e654ae1de154c844341050016a64a0c as sui-node + +WORKDIR /tmp + +RUN curl -L https://github.com/MystenLabs/sui/releases/download/mainnet-v1.19.1/sui-mainnet-v1.19.1-ubuntu-x86_64.tgz > sui-mainnet-v1.19.1-ubuntu-x86_64.tgz +RUN echo "6a8cc96759760293143a00fe7031a5fea70d2dff5b98d18c0470c09555da63e0 sui-mainnet-v1.19.1-ubuntu-x86_64.tgz" | sha256sum -c --status + +RUN tar -xvf sui-mainnet-v1.19.1-ubuntu-x86_64.tgz +RUN mv target/release/sui-ubuntu-x86_64 /bin/sui +RUN mv target/release/sui-faucet-ubuntu-x86_64 /bin/sui-faucet +RUN mv target/release/sui-node-ubuntu-x86_64 /bin/sui-node + +RUN rm sui-mainnet-v1.19.1-ubuntu-x86_64.tgz + +RUN apt-get update +RUN apt-get install -y ca-certificates curl gnupg +RUN mkdir -p /etc/apt/keyrings +RUN curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg + +ARG NODE_MAJOR=18 +RUN echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_$NODE_MAJOR.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list + +RUN apt-get update +RUN apt-get install nodejs -y diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/Makefile b/target_chains/iota/vendor/wormhole_iota_testnet/Makefile new file mode 100644 index 0000000000..0ee0e5eb94 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/Makefile @@ -0,0 +1,15 @@ +TEST_CONTRACT_DIRS := wormhole token_bridge examples/coins examples/core_messages +CLEAN_CONTRACT_DIRS := wormhole token_bridge examples/coins examples/core_messages + +.PHONY: clean +clean: + $(foreach dir,$(TEST_CONTRACT_DIRS), make -C $(dir) $@ &&) true + +.PHONY: test +test: + $(foreach dir,$(TEST_CONTRACT_DIRS), make -C $(dir) $@ &&) true + +test-docker: + DOCKER_BUILDKIT=1 docker build --progress plain -f ../Dockerfile.cli -t cli-gen .. + DOCKER_BUILDKIT=1 docker build --build-arg num_guardians=1 --progress plain -f ../Dockerfile.const -t const-gen .. + DOCKER_BUILDKIT=1 docker build -f Dockerfile .. diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/NOTES.md b/target_chains/iota/vendor/wormhole_iota_testnet/NOTES.md new file mode 100644 index 0000000000..5677cfb924 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/NOTES.md @@ -0,0 +1,114 @@ +brew install cmake + + rustup install stable-x86_64-apple-darwin + #rustup target add stable-x86_64-apple-darwin + rustup target add x86_64-apple-darwin + +=== Building + + % ./node_builder.sh + +=== Running + + % ./start_node.sh + +# If you don't remember your newly generated address + + % sui client addresses + Showing 1 results. + 0x13b3cb89cf3226d3b860294fc75dc6c91f0c5ecf + +# Give yourself some money + + % scripts/faucet.sh `sui client addresses | tail -1` + +# Looking at the prefunded address + + % sui client objects --address 0x13b3cb89cf3226d3b860294fc75dc6c91f0c5ecf + +=== Boot tilt + +# fund our standard account + + We don't run a faucet since it doesn't always unlock the client LOCK files. So, instead we just steal a chunk of coins + from the default accounts created when the node was initialized. Once sui is showing as live... + +``` sh + % kubectl exec -it sui-0 -c sui-node -- /tmp/funder.sh +``` + +# getting into the sui k8s node (if you need to crawl around) + + kubectl exec -it sui-0 -c sui-node -- /bin/bash + kubectl exec -it guardian-0 -c guardiand -- /bin/bash + +# setup the client.yaml + +``` sh + % rm -rf $HOME/.sui + % sui keytool import "daughter exclude wheat pudding police weapon giggle taste space whip satoshi occur" ed25519 + % sui client +``` + point it at http://localhost:9000. The key you create doesn't matter. + +# edit $HOME/.sui/sui_config/client.yaml + +``` sh + sed -i -e 's/active_address.*/active_address: "0x13b3cb89cf3226d3b860294fc75dc6c91f0c5ecf"/' ~/.sui/sui_config/client.yaml +``` + + +# deploy the contract + +``` sh + % scripts/deploy.sh +``` + +# start the watcher + +``` sh + % . env.sh + % python3 tests/ws.py +``` + +# publish a message (different window) + +``` sh + % . env.sh + % scripts/publish_message.sh +``` + +== + +docker run -it -v `pwd`:`pwd` -w `pwd` --net=host ghcr.io/wormhole-foundation/sui:0.16.0 bash +dnf -y install git make + +``` sh + % rm -rf $HOME/.sui + % sui keytool import "daughter exclude wheat pudding police weapon giggle taste space whip satoshi occur" secp256k1 + % sui client +``` + +to get a new emitter + + kubectl exec -it sui-0 -c sui-node -- /tmp/funder.sh + scripts/deploy.sh + . env.sh + sui client call --function get_new_emitter --module wormhole --package $WORM_PACKAGE --gas-budget 20000 --args \"$WORM_STATE\" + + sui client objects + scripts/publish_message.sh 0x165ef7366c4267c6506bcf63d2419556f34f48d6 + + +curl -s -X POST -d '{"jsonrpc":"2.0", "id": 1, "method": "sui_getEvents", "params": [{"MoveEvent": "0xf4179152ab02e4212d7e7b20f37a9a86ab6d50fb::state::WormholeMessage"}, null, 10, true]}' -H 'Content-Type: application/json' http://127.0.0.1:9002 | jq + +curl -s -X POST -d '{"jsonrpc":"2.0", "id": 1, "method": "sui_getEvents", "params": [{"Transaction": "cL+uWFEVcQrkAiOxOJmaK7JmlOJdE3/8X5JFbJwBxCQ="}, null, 10, true]}' -H 'Content-Type: application/json' http://127.0.0.1:9002 | jq + +"txhash": "0x70bfae585115710ae40223b138999a2bb26694e25d137ffc5f92456c9c01c424", "txhash_b58": "8b8Bn8MUqAWeVz2BE5hMicC9KaRkV6UM4v1JLWGUjxcT", " +Digest: cL+uWFEVcQrkAiOxOJmaK7JmlOJdE3/8X5JFbJwBxCQ= + + kubectl exec -it guardian-0 -- /guardiand admin send-observation-request --socket /tmp/admin.sock 21 70bfae585115710ae40223b138999a2bb26694e25d137ffc5f92456c9c01c424 + +// curl -s -X POST -d '{"jsonrpc":"2.0", "id": 1, "method": "sui_getCommitteeInfo", "params": []}' -H 'Content-Type: application/json' http://127.0.0.1:9002 | jq + +// curl -s -X POST -d '{"jsonrpc":"2.0", "id": 1, "method": "sui_getLatestCheckpointSequenceNumber", "params": []}' -H 'Content-Type: application/json' http://127.0.0.1:9000 diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/README.md b/target_chains/iota/vendor/wormhole_iota_testnet/README.md new file mode 100644 index 0000000000..729a8c406c --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/README.md @@ -0,0 +1,130 @@ +# Wormhole on Sui + +This folder contains the reference implementation of the Wormhole cross-chain +messaging protocol smart contracts on the [Sui](https://mystenlabs.com/) +blockchain, implemented in the [Move](https://move-book.com/) programming +language. + +# Project structure + +The project is laid out as follows: + +- [wormhole](./wormhole) the core messaging layer +- [token_bridge](./token_bridge) the asset transfer layer +- [coin](./coin) a template for creating Wormhole wrapped coins + +# Installation + +Make sure your Cargo version is at least 1.65.0 and then follow the steps below: + +- https://docs.sui.io/build/install + +#https://docs.sui.io/guides/developer/getting-started/sui-install# Prerequisites + +Install the `Sui` CLI. This tool is used to compile the contracts and run the tests. + +```sh +cargo install --locked --git https://github.com/MystenLabs/sui.git --rev 041c5f2bae2fe52079e44b70514333532d69f4e6 sui +``` + +Some useful Sui CLI commands are + +- `sui start` to spin up a local network +- `rpc-server` to start a server for handling rpc calls + +Next, install the [worm](../clients/js/README.md) CLI tool by running + +```sh +wormhole/clients/js $ make install +``` + +`worm` is the swiss army knife for interacting with wormhole contracts on all +supported chains, and generating signed messages (VAAs) for testing. + +As an optional, but recommended step, install the +[move-analyzer](https://github.com/move-language/move/tree/main/language/move-analyzer) +Language Server (LSP): + +```sh +cargo install --git https://github.com/move-language/move.git move-analyzer --branch main --features "address32" +``` + +This installs the LSP backend which is then supported by most popular editors such as [emacs](https://github.com/emacs-lsp/lsp-mode), [vim](https://github.com/neoclide/coc.nvim), and even [vscode](https://marketplace.visualstudio.com/items?itemName=move.move-analyzer). + +
+ For emacs, you may need to add the following to your config file: + +```lisp +;; Move +(define-derived-mode move-mode rust-mode "Move" + :group 'move-mode) + +(add-to-list 'auto-mode-alist '("\\.move\\'" . move-mode)) + +(with-eval-after-load 'lsp-mode + (add-to-list 'lsp-language-id-configuration + '(move-mode . "move")) + + (lsp-register-client + (make-lsp-client :new-connection (lsp-stdio-connection "move-analyzer") + :activation-fn (lsp-activate-on "move") + :server-id 'move-analyzer))) +``` + +
+ +## Building & running tests + +The project uses a simple `make`-based build system for building and running +tests. Running `make test` in this directory will run the tests for each +contract. If you only want to run the tests for, say, the token bridge contract, +then you can run `make test` in the `token_bridge` directory, or run `make -C +token_bridge test` from this directory. + +Additionally, `make test-docker` runs the tests in a docker container which is +set up with all the necessary dependencies. This is the command that runs in CI. + +## Running a local validator and deploying the contracts to it + +Simply run + +```sh +worm start-validator sui +``` + +which will start a local sui validator with an RPC endpoint at `0.0.0.0:9000`. + +Once the validator is running, the contracts are ready to deploy. In the +[scripts](./scripts) directory, run + +```sh +scripts $ ./deploy.sh devnet +``` + +This will deploy the core contract and the token bridge. + +When you make a change to the contract, you can simply restart the validator and +run the deploy script again. + + + +# Implementation notes / coding practices + +In this section, we describe some of the implementation design decisions and +coding practices we converged on along the way. Note that the coding guidelines +are prescriptive rather than descriptive, and the goal is for the contracts to +ultimately follow these, but they might not during earlier development phases. + +### TODO diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/devnet/127.0.0.1-36219.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/127.0.0.1-36219.yaml new file mode 100644 index 0000000000..e489d5c3dc --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/127.0.0.1-36219.yaml @@ -0,0 +1,125 @@ +--- +protocol-key-pair: + value: avYcyVgYMXTyaUYh9IRwLK0gSzl7YF6ZQDAbrS1Bhvo= +worker-key-pair: + value: AAvfYqj1HPsXmthZ1t2Uw19vU6tdhK48YAFgkhJ7P/sV +account-key-pair: + value: ABmHnCaxw0GWzW+1MZYfTDonS1wZsO8KO37SXgm6pqc6 +network-key-pair: + value: AEpJ6PVCvnrtaxREy8UNSiDwLPPrZMh12TbgELadmAHB +db-path: /root/.sui/sui_config/authorities_db/8dcff6d15504 +network-address: /ip4/127.0.0.1/tcp/36219/http +json-rpc-address: "127.0.0.1:37179" +enable-experimental-rest-api: true +metrics-address: "127.0.0.1:44423" +admin-interface-port: 35585 +consensus-config: + address: /ip4/127.0.0.1/tcp/35107/http + db-path: /root/.sui/sui_config/consensus_db/8dcff6d15504 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/42177/http + network_admin_server: + primary_network_admin_server_port: 34745 + worker_network_admin_server_base_port: 43111 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:41551" + external-address: /ip4/127.0.0.1/udp/41551 + state-sync: + checkpoint-content-timeout-ms: 10000 +genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false +transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] +certificate-deny-config: {} +state-debug-dump-config: {} +state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false +state-archive-read-config: [] +state-snapshot-write-config: + concurrency: 0 +indexer-max-subscriptions: ~ +transaction-kv-store-read-config: + base-url: "" +jwk-fetch-interval-seconds: 3600 +zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch +authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/devnet/127.0.0.1-36853.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/127.0.0.1-36853.yaml new file mode 100644 index 0000000000..ec936e990a --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/127.0.0.1-36853.yaml @@ -0,0 +1,125 @@ +--- +protocol-key-pair: + value: OXnx3yM1C/ppgnDMx/o1d49fJs7E05kq11mXNae/O+I= +worker-key-pair: + value: AE4ZKvLhbIyoYlv0y7q7aPHyU/Jty/D1AzILgYUs4VqC +account-key-pair: + value: AEAh/lnBSwKKrazfLNz3J7DBu7W2EMuhcShk6MHJhxpT +network-key-pair: + value: AHdOWNkwAgBFMTlwVSGkhI4COGDX40frs5xOz72DHvNm +db-path: /root/.sui/sui_config/authorities_db/addeef94d898 +network-address: /ip4/127.0.0.1/tcp/36853/http +json-rpc-address: "127.0.0.1:34043" +enable-experimental-rest-api: true +metrics-address: "127.0.0.1:45007" +admin-interface-port: 36657 +consensus-config: + address: /ip4/127.0.0.1/tcp/45105/http + db-path: /root/.sui/sui_config/consensus_db/addeef94d898 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/44505/http + network_admin_server: + primary_network_admin_server_port: 45567 + worker_network_admin_server_base_port: 43075 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:37183" + external-address: /ip4/127.0.0.1/udp/37183 + state-sync: + checkpoint-content-timeout-ms: 10000 +genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false +transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] +certificate-deny-config: {} +state-debug-dump-config: {} +state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false +state-archive-read-config: [] +state-snapshot-write-config: + concurrency: 0 +indexer-max-subscriptions: ~ +transaction-kv-store-read-config: + base-url: "" +jwk-fetch-interval-seconds: 3600 +zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch +authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/devnet/127.0.0.1-39101.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/127.0.0.1-39101.yaml new file mode 100644 index 0000000000..9f5954a4d3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/127.0.0.1-39101.yaml @@ -0,0 +1,125 @@ +--- +protocol-key-pair: + value: CyNkjqNVr3HrHTH7f/NLs7u5lUHJzuPAw0PqMTD2y2s= +worker-key-pair: + value: AOuUqLZBJxwz++dkJA9sY0wvTykcCC6jSS3Jqz77IlRI +account-key-pair: + value: AEUws4dzsXHsai5hVbK1O8jWOpPAJjtzdJl32Vxvoj83 +network-key-pair: + value: ADGySwzr54kpKui4vTatL4CtV4/1ffyyHuZ6CMyzZPGI +db-path: /root/.sui/sui_config/authorities_db/b3fd5efb5c87 +network-address: /ip4/127.0.0.1/tcp/39101/http +json-rpc-address: "127.0.0.1:38815" +enable-experimental-rest-api: true +metrics-address: "127.0.0.1:32833" +admin-interface-port: 39835 +consensus-config: + address: /ip4/127.0.0.1/tcp/43831/http + db-path: /root/.sui/sui_config/consensus_db/b3fd5efb5c87 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/40195/http + network_admin_server: + primary_network_admin_server_port: 45269 + worker_network_admin_server_base_port: 39967 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:36503" + external-address: /ip4/127.0.0.1/udp/36503 + state-sync: + checkpoint-content-timeout-ms: 10000 +genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false +transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] +certificate-deny-config: {} +state-debug-dump-config: {} +state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false +state-archive-read-config: [] +state-snapshot-write-config: + concurrency: 0 +indexer-max-subscriptions: ~ +transaction-kv-store-read-config: + base-url: "" +jwk-fetch-interval-seconds: 3600 +zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch +authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/devnet/127.0.0.1-39187.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/127.0.0.1-39187.yaml new file mode 100644 index 0000000000..59b82dc21c --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/127.0.0.1-39187.yaml @@ -0,0 +1,125 @@ +--- +protocol-key-pair: + value: VTDx4HjVmRBqdqBWg2zN+zcFE20io3CrBchGy/iV1lo= +worker-key-pair: + value: ACsedxHqp9Son+iep5m4+eKM+yMc8hYyqhrDJLUucJ+G +account-key-pair: + value: AAAujq3QBAO4JNOYeKBW5dMn+8N4zE4bEHx+Bv9Y5tKr +network-key-pair: + value: AOFPA8/e6v4OpU5U0308llf51JfsxVla/pclVq9Ztajb +db-path: /root/.sui/sui_config/authorities_db/99f25ef61f80 +network-address: /ip4/127.0.0.1/tcp/39187/http +json-rpc-address: "127.0.0.1:33519" +enable-experimental-rest-api: true +metrics-address: "127.0.0.1:33765" +admin-interface-port: 33957 +consensus-config: + address: /ip4/127.0.0.1/tcp/41413/http + db-path: /root/.sui/sui_config/consensus_db/99f25ef61f80 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/35645/http + network_admin_server: + primary_network_admin_server_port: 44333 + worker_network_admin_server_base_port: 43351 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:40869" + external-address: /ip4/127.0.0.1/udp/40869 + state-sync: + checkpoint-content-timeout-ms: 10000 +genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false +transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] +certificate-deny-config: {} +state-debug-dump-config: {} +state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false +state-archive-read-config: [] +state-snapshot-write-config: + concurrency: 0 +indexer-max-subscriptions: ~ +transaction-kv-store-read-config: + base-url: "" +jwk-fetch-interval-seconds: 3600 +zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch +authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/devnet/client.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/client.yaml new file mode 100644 index 0000000000..c9302468b5 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/client.yaml @@ -0,0 +1,12 @@ +--- +keystore: + File: /root/.sui/sui_config/sui.keystore +envs: + - alias: localnet + rpc: "http://0.0.0.0:9000" + ws: ~ + - alias: devnet + rpc: "https://fullnode.devnet.sui.io:443" + ws: ~ +active_env: localnet +active_address: ~ diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/devnet/fullnode.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/fullnode.yaml new file mode 100644 index 0000000000..c89b027b28 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/fullnode.yaml @@ -0,0 +1,107 @@ +--- +protocol-key-pair: + value: JowI/tZTaWZUl32KFepfJUNYnU+0BklUpSPuKEeFcm0= +worker-key-pair: + value: AGIw3mefR34IhvBwYUBAilZJ8Hl8IwJr/BeI1MYwalsR +account-key-pair: + value: AImtWzJTcrcQL00HzJqQy4y0i+XIfZIbK/rUyyaq0f56 +network-key-pair: + value: AGeBrH0F+ehSceQ1zOUs8r2Z2z3iEJ/3RlW0/dN+/dj0 +db-path: full_node_db/full_node_db/b10469f99d8b +network-address: /ip4/127.0.0.1/tcp/42193/http +json-rpc-address: "0.0.0.0:9000" +enable-experimental-rest-api: true +metrics-address: "127.0.0.1:38381" +admin-interface-port: 46743 +enable-event-processing: true +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: ~ +p2p-config: + listen-address: "127.0.0.1:35253" + external-address: /ip4/127.0.0.1/udp/35253 + seed-peers: + - peer-id: e8064daeac1c8801ce3e594cae452f11b453ce616c81974c7b3395d9992a6b37 + address: /ip4/127.0.0.1/udp/40869 + - peer-id: edca3a352dc8953587ffd265df885351c842689252c141960afa0870dfee7439 + address: /ip4/127.0.0.1/udp/41551 + - peer-id: d5e061082e23e6bbe75d1f0fcfcb982967f84c700e2c558482990dde14d8fd1b + address: /ip4/127.0.0.1/udp/37183 + - peer-id: 0395788680d90c7debf0671c18a608018d5800322459c7bc35ce0ee49cf6eeba + address: /ip4/127.0.0.1/udp/36503 + state-sync: + checkpoint-content-timeout-ms: 10000 +genesis: + genesis: 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 +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: true + enable-deep-per-tx-sui-conservation-check: true + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: true + force-disable-state-consistency-check: false + enable-secondary-index-checks: false +transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] +certificate-deny-config: {} +state-debug-dump-config: {} +state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false +state-archive-read-config: [] +state-snapshot-write-config: + concurrency: 0 +indexer-max-subscriptions: ~ +transaction-kv-store-read-config: + base-url: "" +jwk-fetch-interval-seconds: 3600 +zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch +authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/devnet/genesis.blob b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/genesis.blob new file mode 100644 index 0000000000..5d1cb997ea Binary files /dev/null and b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/genesis.blob differ diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/devnet/genesis_config b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/genesis_config new file mode 100644 index 0000000000..aeb16458fa --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/genesis_config @@ -0,0 +1,55 @@ +--- +ssfn_config_info: ~ +validator_config_info: ~ +parameters: + chain_start_timestamp_ms: 1709486339140 + protocol_version: 36 + allow_insertion_of_extra_objects: true + epoch_duration_ms: 86400000 + stake_subsidy_start_epoch: 0 + stake_subsidy_initial_distribution_amount: 1000000000000000 + stake_subsidy_period_length: 10 + stake_subsidy_decrease_rate: 1000 +accounts: + - address: "0x2e425dd30f43ff1d59547322839cfc4b8fbaae54d72075181ebd7388b644fdbe" + gas_amounts: + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - address: "0x8a8bb058d6c86aa175566c9e2d19278dd22ed9fecdda8fb486018f93a0629bb5" + gas_amounts: + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - address: "0xa0f33ce147ecae789f535c64634851724284dd618a529672702b991a5f7bf816" + gas_amounts: + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - address: "0xbd00a48078c0513a5f9a0d1c9352cd5c23a0e0cf3e6a82673cdae857cd00021e" + gas_amounts: + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - address: "0xfd5f84cf9285f2b206e03727224b9daffa6092661b840d92434751792010b7de" + gas_amounts: + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - address: "0xed867315e3f7c83ae82e6d5858b6a6cc57c291fd84f7509646ebc8162169cf96" + gas_amounts: + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/devnet/network.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/network.yaml new file mode 100644 index 0000000000..c6206fc155 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/devnet/network.yaml @@ -0,0 +1,500 @@ +--- +validator_configs: + - protocol-key-pair: + value: VTDx4HjVmRBqdqBWg2zN+zcFE20io3CrBchGy/iV1lo= + worker-key-pair: + value: ACsedxHqp9Son+iep5m4+eKM+yMc8hYyqhrDJLUucJ+G + account-key-pair: + value: AAAujq3QBAO4JNOYeKBW5dMn+8N4zE4bEHx+Bv9Y5tKr + network-key-pair: + value: AOFPA8/e6v4OpU5U0308llf51JfsxVla/pclVq9Ztajb + db-path: /root/.sui/sui_config/authorities_db/99f25ef61f80 + network-address: /ip4/127.0.0.1/tcp/39187/http + json-rpc-address: "127.0.0.1:33519" + enable-experimental-rest-api: true + metrics-address: "127.0.0.1:33765" + admin-interface-port: 33957 + consensus-config: + address: /ip4/127.0.0.1/tcp/41413/http + db-path: /root/.sui/sui_config/consensus_db/99f25ef61f80 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/35645/http + network_admin_server: + primary_network_admin_server_port: 44333 + worker_network_admin_server_base_port: 43351 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:40869" + external-address: /ip4/127.0.0.1/udp/40869 + state-sync: + checkpoint-content-timeout-ms: 10000 + genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false + transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] + certificate-deny-config: {} + state-debug-dump-config: {} + state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false + state-archive-read-config: [] + state-snapshot-write-config: + concurrency: 0 + indexer-max-subscriptions: ~ + transaction-kv-store-read-config: + base-url: "" + jwk-fetch-interval-seconds: 3600 + zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch + authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 + - protocol-key-pair: + value: avYcyVgYMXTyaUYh9IRwLK0gSzl7YF6ZQDAbrS1Bhvo= + worker-key-pair: + value: AAvfYqj1HPsXmthZ1t2Uw19vU6tdhK48YAFgkhJ7P/sV + account-key-pair: + value: ABmHnCaxw0GWzW+1MZYfTDonS1wZsO8KO37SXgm6pqc6 + network-key-pair: + value: AEpJ6PVCvnrtaxREy8UNSiDwLPPrZMh12TbgELadmAHB + db-path: /root/.sui/sui_config/authorities_db/8dcff6d15504 + network-address: /ip4/127.0.0.1/tcp/36219/http + json-rpc-address: "127.0.0.1:37179" + enable-experimental-rest-api: true + metrics-address: "127.0.0.1:44423" + admin-interface-port: 35585 + consensus-config: + address: /ip4/127.0.0.1/tcp/35107/http + db-path: /root/.sui/sui_config/consensus_db/8dcff6d15504 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/42177/http + network_admin_server: + primary_network_admin_server_port: 34745 + worker_network_admin_server_base_port: 43111 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:41551" + external-address: /ip4/127.0.0.1/udp/41551 + state-sync: + checkpoint-content-timeout-ms: 10000 + genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false + transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] + certificate-deny-config: {} + state-debug-dump-config: {} + state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false + state-archive-read-config: [] + state-snapshot-write-config: + concurrency: 0 + indexer-max-subscriptions: ~ + transaction-kv-store-read-config: + base-url: "" + jwk-fetch-interval-seconds: 3600 + zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch + authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 + - protocol-key-pair: + value: OXnx3yM1C/ppgnDMx/o1d49fJs7E05kq11mXNae/O+I= + worker-key-pair: + value: AE4ZKvLhbIyoYlv0y7q7aPHyU/Jty/D1AzILgYUs4VqC + account-key-pair: + value: AEAh/lnBSwKKrazfLNz3J7DBu7W2EMuhcShk6MHJhxpT + network-key-pair: + value: AHdOWNkwAgBFMTlwVSGkhI4COGDX40frs5xOz72DHvNm + db-path: /root/.sui/sui_config/authorities_db/addeef94d898 + network-address: /ip4/127.0.0.1/tcp/36853/http + json-rpc-address: "127.0.0.1:34043" + enable-experimental-rest-api: true + metrics-address: "127.0.0.1:45007" + admin-interface-port: 36657 + consensus-config: + address: /ip4/127.0.0.1/tcp/45105/http + db-path: /root/.sui/sui_config/consensus_db/addeef94d898 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/44505/http + network_admin_server: + primary_network_admin_server_port: 45567 + worker_network_admin_server_base_port: 43075 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:37183" + external-address: /ip4/127.0.0.1/udp/37183 + state-sync: + checkpoint-content-timeout-ms: 10000 + genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false + transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] + certificate-deny-config: {} + state-debug-dump-config: {} + state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false + state-archive-read-config: [] + state-snapshot-write-config: + concurrency: 0 + indexer-max-subscriptions: ~ + transaction-kv-store-read-config: + base-url: "" + jwk-fetch-interval-seconds: 3600 + zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch + authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 + - protocol-key-pair: + value: CyNkjqNVr3HrHTH7f/NLs7u5lUHJzuPAw0PqMTD2y2s= + worker-key-pair: + value: AOuUqLZBJxwz++dkJA9sY0wvTykcCC6jSS3Jqz77IlRI + account-key-pair: + value: AEUws4dzsXHsai5hVbK1O8jWOpPAJjtzdJl32Vxvoj83 + network-key-pair: + value: ADGySwzr54kpKui4vTatL4CtV4/1ffyyHuZ6CMyzZPGI + db-path: /root/.sui/sui_config/authorities_db/b3fd5efb5c87 + network-address: /ip4/127.0.0.1/tcp/39101/http + json-rpc-address: "127.0.0.1:38815" + enable-experimental-rest-api: true + metrics-address: "127.0.0.1:32833" + admin-interface-port: 39835 + consensus-config: + address: /ip4/127.0.0.1/tcp/43831/http + db-path: /root/.sui/sui_config/consensus_db/b3fd5efb5c87 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/40195/http + network_admin_server: + primary_network_admin_server_port: 45269 + worker_network_admin_server_base_port: 39967 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:36503" + external-address: /ip4/127.0.0.1/udp/36503 + state-sync: + checkpoint-content-timeout-ms: 10000 + genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false + transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] + certificate-deny-config: {} + state-debug-dump-config: {} + state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false + state-archive-read-config: [] + state-snapshot-write-config: + concurrency: 0 + indexer-max-subscriptions: ~ + transaction-kv-store-read-config: + base-url: "" + jwk-fetch-interval-seconds: 3600 + zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch + authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 +account_keys: [] +genesis: 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 diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/.gitignore b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/.gitignore new file mode 100644 index 0000000000..378eac25d3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/.gitignore @@ -0,0 +1 @@ +build diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/Makefile b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/Makefile new file mode 100644 index 0000000000..9b862faf0a --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/Makefile @@ -0,0 +1,15 @@ +.PHONY: all clean test check + +all: check + +.PHONY: clean +clean: + rm -rf build + +.PHONY: check +check: + sui move build -d + +.PHONY: test +test: check + sui move test -d diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/Move.devnet.toml b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/Move.devnet.toml new file mode 100644 index 0000000000..b505feb87d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/Move.devnet.toml @@ -0,0 +1,17 @@ +[package] +name = "Coins" +version = "0.1.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../../wormhole" + +[dependencies.TokenBridge] +local = "../../token_bridge" + +[addresses] +coins = "_" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/Move.lock b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/Move.lock new file mode 100644 index 0000000000..26f89cf4a1 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/Move.lock @@ -0,0 +1,52 @@ +# @generated by Move, please check-in and do not edit manually. + +[move] +version = 0 +manifest_digest = "F1027436A2346E82F07F1149F91C26F61778F611858CEA83F9D22BDEF50A7FD8" +deps_digest = "397E6A9F7A624706DBDFEE056CE88391A15876868FD18A88504DA74EB458D697" + +dependencies = [ + { name = "Sui" }, +] + +dev-dependencies = [ + { name = "TokenBridge" }, + { name = "Wormhole" }, +] + +[[move.package]] +name = "MoveStdlib" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/move-stdlib" } + +[[move.package]] +name = "Sui" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/sui-framework" } + +dependencies = [ + { name = "MoveStdlib" }, +] + +[[move.package]] +name = "TokenBridge" +source = { local = "../../token_bridge" } + +dependencies = [ + { name = "Sui" }, +] + +dev-dependencies = [ + { name = "Wormhole" }, +] + +[[move.package]] +name = "Wormhole" +source = { local = "../../wormhole" } + +dependencies = [ + { name = "Sui" }, +] + +[move.toolchain-version] +compiler-version = "1.19.0" +edition = "legacy" +flavor = "sui" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/Move.toml b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/Move.toml new file mode 100644 index 0000000000..ac052a42c4 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/Move.toml @@ -0,0 +1,28 @@ +[package] +name = "Coins" +version = "0.1.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../../wormhole" + +[dependencies.TokenBridge] +local = "../../token_bridge" + +[addresses] +coins = "_" + +[dev-dependencies.Wormhole] +local = "../../wormhole" + +[dev-dependencies.TokenBridge] +local = "../../token_bridge" + +[dev-addresses] +wormhole = "0x100" +token_bridge = "0x200" +coins = "0x20c" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/sources/coin.move b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/sources/coin.move new file mode 100644 index 0000000000..9992667e29 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/sources/coin.move @@ -0,0 +1,210 @@ +// Example wrapped coin for testing purposes + +#[test_only] +module coins::coin { + use iota::object::{Self}; + use iota::package::{Self}; + use iota::transfer::{Self}; + use iota::tx_context::{Self, TxContext}; + + use token_bridge::create_wrapped::{Self}; + + struct COIN has drop {} + + fun init(witness: COIN, ctx: &mut TxContext) { + use token_bridge::version_control::{V__0_2_0 as V__CURRENT}; + + transfer::public_transfer( + create_wrapped::prepare_registration( + witness, + // TODO: create a version of this for each decimal to be used + 8, + ctx + ), + tx_context::sender(ctx) + ); + } + + #[test_only] + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_test_only(ctx: &mut TxContext) { + init(COIN {}, ctx); + + // This will be created and sent to the transaction sender + // automatically when the contract is published. + transfer::public_transfer( + package::test_publish(object::id_from_address(@coins), ctx), + tx_context::sender(ctx) + ); + } +} + +#[test_only] +module coins::coin_tests { + use iota::coin::{Self}; + use iota::package::{UpgradeCap}; + use iota::test_scenario::{Self}; + use token_bridge::create_wrapped::{Self, WrappedAssetSetup}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + register_dummy_emitter, + return_state, + set_up_wormhole_and_token_bridge, + take_state, + two_people + }; + use token_bridge::token_registry::{Self}; + use token_bridge::vaa::{Self}; + use token_bridge::wrapped_asset::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::external_address::{Self}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + use token_bridge::version_control::{V__0_2_0 as V__CURRENT}; + + use coins::coin::{COIN}; + +// +------------------------------------------------------------------------------+ +// | Wormhole VAA v1 | nonce: 1 | time: 1 | +// | guardian set #0 | #22080291 | consistency: 0 | +// |------------------------------------------------------------------------------| +// | Signature: | +// | #0: 80366065746148420220f25a6275097370e8db40984529a6676b7a5fc9fe... | +// |------------------------------------------------------------------------------| +// | Emitter: 0x00000000000000000000000000000000deadbeef (Ethereum) | +// |==============================================================================| +// | Token attestation | +// | decimals: 12 | +// | Token: 0x00000000000000000000000000000000beefface (Ethereum) | +// | Symbol: BEEF | +// | Name: Beef face Token | +// +------------------------------------------------------------------------------+ + const VAA: vector = + x"0100000000010080366065746148420220f25a6275097370e8db40984529a6676b7a5fc9feb11755ec49ca626b858ddfde88d15601f85ab7683c5f161413b0412143241c700aff010000000100000001000200000000000000000000000000000000000000000000000000000000deadbeef000000000150eb23000200000000000000000000000000000000000000000000000000000000beefface00020c424545460000000000000000000000000000000000000000000000000000000042656566206661636520546f6b656e0000000000000000000000000000000000"; + +// +------------------------------------------------------------------------------+ +// | Wormhole VAA v1 | nonce: 69 | time: 0 | +// | guardian set #0 | #1 | consistency: 15 | +// |------------------------------------------------------------------------------| +// | Signature: | +// | #0: b0571650590e147fce4eb60105e0463522c1244a97bd5dcb365d3e7bc7f3... | +// |------------------------------------------------------------------------------| +// | Emitter: 0x00000000000000000000000000000000deadbeef (Ethereum) | +// |==============================================================================| +// | Token attestation | +// | decimals: 12 | +// | Token: 0x00000000000000000000000000000000beefface (Ethereum) | +// | Symbol: BEEF??? and profit | +// | Name: Beef face Token??? and profit | +// +------------------------------------------------------------------------------+ + const UPDATED_VAA: vector = + x"0100000000010062f4dcd21bbbc4af8b8baaa2da3a0b168efc4c975de5b828c7a3c710b67a0a0d476d10a74aba7a7867866daf97d1372d8e6ee62ccc5ae522e3e603c67fa23787000000000000000045000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f0200000000000000000000000000000000000000000000000000000000beefface00020c424545463f3f3f20616e642070726f666974000000000000000000000000000042656566206661636520546f6b656e3f3f3f20616e642070726f666974000000"; + + + #[test] + public fun test_complete_and_update_attestation() { + let (caller, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. Make sure `coin_deployer` receives + // `WrappedAssetSetup`. + test_scenario::next_tx(scenario, coin_deployer); + + // Publish coin. + coins::coin::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, coin_deployer); + + let wrapped_asset_setup = + test_scenario::take_from_address>( + scenario, + coin_deployer + ); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + let coin_meta = test_scenario::take_shared(scenario); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + wrapped_asset_setup, + test_scenario::take_from_address( + scenario, + coin_deployer + ), + msg + ); + + // Check registry. + { + let verified = state::verified_asset(&token_bridge_state); + assert!(token_bridge::token_registry::is_wrapped(&verified), 0); + + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == 0, 0); + + // Decimals are capped for this wrapped asset. + assert!(coin::get_decimals(&coin_meta) == 8, 0); + + // Check metadata against asset metadata. + let info = wrapped_asset::info(asset); + assert!(wrapped_asset::token_chain(info) == 2, 0); + assert!(wrapped_asset::token_address(info) == external_address::new(bytes32::from_bytes(x"00000000000000000000000000000000beefface")), 0); + assert!( + wrapped_asset::native_decimals(info) == 12, + 0 + ); + assert!(coin::get_symbol(&coin_meta) == std::ascii::string(b"BEEF"), 0); + assert!(coin::get_name(&coin_meta) == std::string::utf8(b"Beef face Token"), 0); + }; + + let verified_vaa = + parse_and_verify_vaa(scenario, UPDATED_VAA); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Now update metadata. + create_wrapped::update_attestation(&mut token_bridge_state, &mut coin_meta, msg); + + // Check updated name and symbol. + assert!( + coin::get_name(&coin_meta) == std::string::utf8(b"Beef face Token??? and profit"), + 0 + ); + assert!( + coin::get_symbol(&coin_meta) == std::ascii::string(b"BEEF??? and profit"), + 0 + ); + + // Clean up. + return_state(token_bridge_state); + test_scenario::return_shared(coin_meta); + + + // Done. + test_scenario::end(my_scenario); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/sources/coin_10.move b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/sources/coin_10.move new file mode 100644 index 0000000000..02fa816d27 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/sources/coin_10.move @@ -0,0 +1,72 @@ +module coins::coin_10 { + use std::option; + use iota::coin::{Self, TreasuryCap, CoinMetadata}; + use iota::transfer; + use iota::tx_context::{Self, TxContext}; + + /// The type identifier of coin. The coin will have a type + /// tag of kind: `Coin` + /// Make sure that the name of the type matches the module's name. + struct COIN_10 has drop {} + + /// Module initializer is called once on module publish. A treasury + /// cap is sent to the publisher, who then controls minting and burning + fun init(witness: COIN_10, ctx: &mut TxContext) { + let (treasury, metadata) = create_coin(witness, ctx); + transfer::public_freeze_object(metadata); + transfer::public_transfer(treasury, tx_context::sender(ctx)); + } + + fun create_coin( + witness: COIN_10, + ctx: &mut TxContext + ): (TreasuryCap, CoinMetadata) { + coin::create_currency( + witness, + 10, // decimals + b"COIN_10", // symbol + b"10-Decimal Coin", // name + b"", // description + option::none(), // icon_url + ctx + ) + } + + #[test_only] + public fun create_coin_test_only( + ctx: &mut TxContext + ): (TreasuryCap, CoinMetadata) { + create_coin(COIN_10 {}, ctx) + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_10 {}, ctx) + } +} + +#[test_only] +module coins::coin_10_tests { + use iota::test_scenario::{Self}; + + use coins::coin_10::{Self}; + + #[test] + public fun init_test() { + let my_scenario = test_scenario::begin(@0x0); + let scenario = &mut my_scenario; + let creator = @0xDEADBEEF; + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Init. + coin_10::init_test_only(test_scenario::ctx(scenario)); + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Done. + test_scenario::end(my_scenario); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/sources/coin_8.move b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/sources/coin_8.move new file mode 100644 index 0000000000..26bbb35819 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/coins/sources/coin_8.move @@ -0,0 +1,72 @@ +module coins::coin_8 { + use std::option::{Self}; + use iota::coin::{Self, TreasuryCap, CoinMetadata}; + use iota::transfer::{Self}; + use iota::tx_context::{Self, TxContext}; + + /// The type identifier of coin. The coin will have a type + /// tag of kind: `Coin` + /// Make sure that the name of the type matches the module's name. + struct COIN_8 has drop {} + + /// Module initializer is called once on module publish. A treasury + /// cap is sent to the publisher, who then controls minting and burning + fun init(witness: COIN_8, ctx: &mut TxContext) { + let (treasury, metadata) = create_coin(witness, ctx); + transfer::public_freeze_object(metadata); + transfer::public_transfer(treasury, tx_context::sender(ctx)); + } + + fun create_coin( + witness: COIN_8, + ctx: &mut TxContext + ): (TreasuryCap, CoinMetadata) { + coin::create_currency( + witness, + 8, // decimals + b"COIN_8", // symbol + b"8-Decimal Coin", // name + b"", // description + option::none(), // icon_url + ctx + ) + } + + #[test_only] + public fun create_coin_test_only( + ctx: &mut TxContext + ): (TreasuryCap, CoinMetadata) { + create_coin(COIN_8 {}, ctx) + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_8 {}, ctx) + } +} + +#[test_only] +module coins::coin_8_tests { + use iota::test_scenario::{Self}; + + use coins::coin_8::{Self}; + + #[test] + public fun init_test() { + let my_scenario = test_scenario::begin(@0x0); + let scenario = &mut my_scenario; + let creator = @0xDEADBEEF; + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Init. + coin_8::init_test_only(test_scenario::ctx(scenario)); + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Done. + test_scenario::end(my_scenario); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/Makefile b/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/Makefile new file mode 100644 index 0000000000..210a28de7a --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/Makefile @@ -0,0 +1,20 @@ +-include ../../../Makefile.help + +.PHONY: artifacts +artifacts: clean + +.PHONY: clean +# Clean build artifacts +clean: + rm -rf build + +.PHONY: build +# Build contract +build: + sui move build + +.PHONY: test +# Run tests +test: + sui move build -d || exit $? + sui move test -t 1 diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/Move.devnet.toml b/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/Move.devnet.toml new file mode 100644 index 0000000000..d9363b2554 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/Move.devnet.toml @@ -0,0 +1,14 @@ +[package] +name = "CoreMessages" +version = "1.0.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../../wormhole" + +[addresses] +core_messages = "_" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/Move.lock b/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/Move.lock new file mode 100644 index 0000000000..9bddcd1268 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/Move.lock @@ -0,0 +1,39 @@ +# @generated by Move, please check-in and do not edit manually. + +[move] +version = 0 +manifest_digest = "E0D2B32F0A5B6F9A76311FD7A68260A698BD9ECCEAF95A779183CB374EC933FB" +deps_digest = "060AD7E57DFB13104F21BE5F5C3759D03F0553FC3229247D9A7A6B45F50D03A3" + +dependencies = [ + { name = "Sui" }, +] + +dev-dependencies = [ + { name = "Wormhole" }, +] + +[[move.package]] +name = "MoveStdlib" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/move-stdlib" } + +[[move.package]] +name = "Sui" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/sui-framework" } + +dependencies = [ + { name = "MoveStdlib" }, +] + +[[move.package]] +name = "Wormhole" +source = { local = "../../wormhole" } + +dependencies = [ + { name = "Sui" }, +] + +[move.toolchain-version] +compiler-version = "1.19.0" +edition = "legacy" +flavor = "sui" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/Move.toml b/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/Move.toml new file mode 100644 index 0000000000..38872b17dc --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/Move.toml @@ -0,0 +1,21 @@ +[package] +name = "CoreMessages" +version = "1.0.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../../wormhole" + +[addresses] +core_messages = "_" + +[dev-dependencies.Wormhole] +local = "../../wormhole" + +[dev-addresses] +wormhole = "0x100" +core_messages = "0x169" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/sources/sender.move b/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/sources/sender.move new file mode 100644 index 0000000000..2f26f009f4 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/core_messages/sources/sender.move @@ -0,0 +1,149 @@ +/// A simple contracts that demonstrates how to send messages with wormhole. +module core_messages::sender { + use iota::clock::{Clock}; + use iota::coin::{Self}; + use iota::object::{Self, UID}; + use iota::transfer::{Self}; + use iota::tx_context::{TxContext}; + use wormhole::emitter::{Self, EmitterCap}; + use wormhole::state::{State as WormholeState}; + + struct State has key, store { + id: UID, + emitter_cap: EmitterCap, + } + + /// Register ourselves as a wormhole emitter. This gives back an + /// `EmitterCap` which will be required to send messages through + /// wormhole. + public fun init_with_params( + wormhole_state: &WormholeState, + ctx: &mut TxContext + ) { + transfer::share_object( + State { + id: object::new(ctx), + emitter_cap: emitter::new(wormhole_state, ctx) + } + ); + } + + public fun send_message_entry( + state: &mut State, + wormhole_state: &mut WormholeState, + payload: vector, + the_clock: &Clock, + ctx: &mut TxContext + ) { + send_message( + state, + wormhole_state, + payload, + the_clock, + ctx + ); + } + + /// NOTE: This is NOT the proper way of using the `prepare_message` and + /// `publish_message` workflow. This example app is meant for testing for + /// observing Wormhole messages via the guardian. + /// + /// See `publish_message` module for more info. + public fun send_message( + state: &mut State, + wormhole_state: &mut WormholeState, + payload: vector, + the_clock: &Clock, + ctx: &mut TxContext + ): u64 { + use wormhole::publish_message::{prepare_message, publish_message}; + + // NOTE AGAIN: Integrators should NEVER call this within their contract. + publish_message( + wormhole_state, + coin::zero(ctx), + prepare_message( + &mut state.emitter_cap, + 0, // Set nonce to 0, intended for batch VAAs. + payload + ), + the_clock + ) + } +} + +#[test_only] +module core_messages::sender_test { + use iota::test_scenario::{Self}; + use wormhole::wormhole_scenario::{ + return_clock, + return_state, + set_up_wormhole, + take_clock, + take_state, + two_people, + }; + + use core_messages::sender::{ + State, + init_with_params, + send_message, + }; + + #[test] + public fun test_send_message() { + let (user, admin) = two_people(); + let my_scenario = test_scenario::begin(admin); + let scenario = &mut my_scenario; + + // Initialize Wormhole. + let wormhole_message_fee = 0; + set_up_wormhole(scenario, wormhole_message_fee); + + // Initialize sender module. + test_scenario::next_tx(scenario, admin); + { + let wormhole_state = take_state(scenario); + init_with_params(&wormhole_state, test_scenario::ctx(scenario)); + return_state(wormhole_state); + }; + + // Send message as an ordinary user. + test_scenario::next_tx(scenario, user); + { + let state = test_scenario::take_shared(scenario); + let wormhole_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let first_message_sequence = send_message( + &mut state, + &mut wormhole_state, + b"Hello", + &the_clock, + test_scenario::ctx(scenario) + ); + assert!(first_message_sequence == 0, 0); + + let second_message_sequence = send_message( + &mut state, + &mut wormhole_state, + b"World", + &the_clock, + test_scenario::ctx(scenario) + ); + assert!(second_message_sequence == 1, 0); + + // Clean up. + test_scenario::return_shared(state); + return_state(wormhole_state); + return_clock(the_clock); + }; + + // Check effects. + let effects = test_scenario::next_tx(scenario, user); + assert!(test_scenario::num_user_events(&effects) == 2, 0); + + // End test. + test_scenario::end(my_scenario); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/templates/README.md b/target_chains/iota/vendor/wormhole_iota_testnet/examples/templates/README.md new file mode 100644 index 0000000000..41a8dbd907 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/templates/README.md @@ -0,0 +1,3 @@ +# Templates + +This directory contains templates for Sui contracts. These templates aren't fully functional contracts and require substitution of variables prior to deployment. For example, the `wrapped_coin` template requires the version control struct name as well as the decimals of the wrapped token. diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/templates/wrapped_coin/Move.toml b/target_chains/iota/vendor/wormhole_iota_testnet/examples/templates/wrapped_coin/Move.toml new file mode 100644 index 0000000000..0c25220b1d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/templates/wrapped_coin/Move.toml @@ -0,0 +1,19 @@ +[package] +name = "WrappedCoin" +version = "0.0.1" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../../wormhole" + +[dependencies.TokenBridge] +local = "../../token_bridge" + +[addresses] +wormhole = "_" +token_bridge = "_" +wrapped_coin = "0x0" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/examples/templates/wrapped_coin/sources/coin.move b/target_chains/iota/vendor/wormhole_iota_testnet/examples/templates/wrapped_coin/sources/coin.move new file mode 100644 index 0000000000..096432f03e --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/examples/templates/wrapped_coin/sources/coin.move @@ -0,0 +1,21 @@ +module wrapped_coin::coin { + use iota::transfer::{Self}; + use iota::tx_context::{Self, TxContext}; + + use token_bridge::create_wrapped::{Self}; + + struct COIN has drop {} + + fun init(witness: COIN, ctx: &mut TxContext) { + use token_bridge::version_control::{{{VERSION}}}; + + transfer::public_transfer( + create_wrapped::prepare_registration( + witness, + {{DECIMALS}}, + ctx + ), + tx_context::sender(ctx) + ); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/scripts/deploy.sh b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/deploy.sh new file mode 100755 index 0000000000..d572f8cbf0 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/deploy.sh @@ -0,0 +1,119 @@ +#!/usr/bin/env bash + +set -euo pipefail + +# Help message +function usage() { +cat <&2 +Deploy and initialize Sui core bridge and token bridge contracts to the +specified network. Additionally deploys an example messaging contract in +devnet. + + Usage: $(basename "$0") [options] + + Positional args: + Network to deploy to (devnet, testnet, mainnet) + + Options: + -k, --private-key Use given key to sign transactions + -h, --help Show this help message +EOF +exit 1 +} + +# If positional args are missing, print help message and exit +if [ $# -lt 1 ]; then + usage +fi + +# Default values +PRIVATE_KEY_ARG= + +# Set network +NETWORK=$1 || usage +shift + +# Set guardian address +if [ "$NETWORK" = mainnet ]; then + echo "Mainnet not supported yet" + exit 1 +elif [ "$NETWORK" = testnet ]; then + echo "Testnet not supported yet" + exit 1 +elif [ "$NETWORK" = devnet ]; then + GUARDIAN_ADDR=befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe +else + usage +fi + +# Parse short/long flags +while [[ $# -gt 0 ]]; do + case "$1" in + -k|--private-key) + if [[ ! -z "$2" ]]; then + PRIVATE_KEY_ARG="-k $2" + fi + shift 2 + ;; + -h|--help) + usage + exit 0 + ;; + *) + echo "Unknown option: $1" + usage + exit 1 + ;; + esac +done + +# Assumes this script is in a sibling directory to contract dirs +DIRNAME=$(dirname "$0") +WORMHOLE_PATH=$(realpath "$DIRNAME"/../wormhole) +TOKEN_BRIDGE_PATH=$(realpath "$DIRNAME"/../token_bridge) +EXAMPLE_APP_PATH=$(realpath "$DIRNAME"/../examples/core_messages) +EXAMPLE_COIN_PATH=$(realpath "$DIRNAME"/../examples/coins) + +echo -e "[1/4] Publishing core bridge contracts..." +WORMHOLE_PUBLISH_OUTPUT=$($(echo worm sui deploy "$WORMHOLE_PATH" -n "$NETWORK" "$PRIVATE_KEY_ARG")) +echo "$WORMHOLE_PUBLISH_OUTPUT" + +echo -e "\n[2/4] Initializing core bridge..." +WORMHOLE_PACKAGE_ID=$(echo "$WORMHOLE_PUBLISH_OUTPUT" | grep -oP 'Published to +\K.*') +WORMHOLE_INIT_OUTPUT=$($(echo worm sui init-wormhole -n "$NETWORK" --initial-guardian "$GUARDIAN_ADDR" -p "$WORMHOLE_PACKAGE_ID" "$PRIVATE_KEY_ARG")) +WORMHOLE_STATE_OBJECT_ID=$(echo "$WORMHOLE_INIT_OUTPUT" | grep -oP 'Wormhole state object ID +\K.*') +echo "$WORMHOLE_INIT_OUTPUT" + +echo -e "\n[3/4] Publishing token bridge contracts..." +TOKEN_BRIDGE_PUBLISH_OUTPUT=$($(echo worm sui deploy "$TOKEN_BRIDGE_PATH" -n "$NETWORK" "$PRIVATE_KEY_ARG")) +echo "$TOKEN_BRIDGE_PUBLISH_OUTPUT" + +echo -e "\n[4/4] Initializing token bridge..." +TOKEN_BRIDGE_PACKAGE_ID=$(echo "$TOKEN_BRIDGE_PUBLISH_OUTPUT" | grep -oP 'Published to +\K.*') +TOKEN_BRIDGE_INIT_OUTPUT=$($(echo worm sui init-token-bridge -n "$NETWORK" -p "$TOKEN_BRIDGE_PACKAGE_ID" -w "$WORMHOLE_STATE_OBJECT_ID" "$PRIVATE_KEY_ARG")) +TOKEN_BRIDGE_STATE_OBJECT_ID=$(echo "$TOKEN_BRIDGE_INIT_OUTPUT" | grep -oP 'Token bridge state object ID +\K.*') +echo "$TOKEN_BRIDGE_INIT_OUTPUT" + +if [ "$NETWORK" = devnet ]; then + echo -e "\n[+1/2] Deploying and initializing example app..." + EXAMPLE_APP_PUBLISH_OUTPUT=$($(echo worm sui deploy "$EXAMPLE_APP_PATH" -n "$NETWORK" "$PRIVATE_KEY_ARG")) + EXAMPLE_APP_PACKAGE_ID=$(echo "$EXAMPLE_APP_PUBLISH_OUTPUT" | grep -oP 'Published to +\K.*') + echo "$EXAMPLE_APP_PUBLISH_OUTPUT" + + EXAMPLE_INIT_OUTPUT=$($(echo worm sui init-example-message-app -n "$NETWORK" -p "$EXAMPLE_APP_PACKAGE_ID" -w "$WORMHOLE_STATE_OBJECT_ID" "$PRIVATE_KEY_ARG")) + EXAMPLE_APP_STATE_OBJECT_ID=$(echo "$EXAMPLE_INIT_OUTPUT" | grep -oP 'Example app state object ID +\K.*') + echo "$EXAMPLE_INIT_OUTPUT" + + echo -e "\n[+2/2] Deploying example coins..." + EXAMPLE_COIN_PUBLISH_OUTPUT=$($(echo worm sui deploy "$EXAMPLE_COIN_PATH" -n "$NETWORK" "$PRIVATE_KEY_ARG")) + echo "$EXAMPLE_COIN_PUBLISH_OUTPUT" + + echo -e "\nWormhole package ID: $WORMHOLE_PACKAGE_ID" + echo "Token bridge package ID: $TOKEN_BRIDGE_PACKAGE_ID" + echo "Wormhole state object ID: $WORMHOLE_STATE_OBJECT_ID" + echo "Token bridge state object ID: $TOKEN_BRIDGE_STATE_OBJECT_ID" + + echo -e "\nPublish message command:" worm sui publish-example-message -n devnet -p "$EXAMPLE_APP_PACKAGE_ID" -s "$EXAMPLE_APP_STATE_OBJECT_ID" -w "$WORMHOLE_STATE_OBJECT_ID" -m "hello" "$PRIVATE_KEY_ARG" +fi + +echo -e "\nDeployments successful!" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/scripts/node_builder.sh b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/node_builder.sh new file mode 100755 index 0000000000..940017e330 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/node_builder.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +git clone https://github.com/MystenLabs/sui.git --branch devnet +cd sui +# Corresponds to https://github.com/MystenLabs/sui/releases/tag/mainnet-v1.19.1 +git reset --hard 041c5f2bae2fe52079e44b70514333532d69f4e6 + +cargo --locked install --path crates/sui +cargo --locked install --path crates/sui-faucet +cargo --locked install --path crates/sui-gateway +cargo --locked install --path crates/sui-node diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/scripts/register_devnet.sh b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/register_devnet.sh new file mode 100755 index 0000000000..79df935672 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/register_devnet.sh @@ -0,0 +1,22 @@ +#!/bin/bash + +set -e + +DOTENV=$(realpath "$(dirname "$0")"/../.env) +[ -f $DOTENV ] || (echo "$DOTENV does not exist." >&2; exit 1) + +# 1. load variables from .env file +. $DOTENV + +# 2. next we get all the token bridge registration VAAs from the environment +# if a new VAA is added, this will automatically pick it up +VAAS=$(set | grep "REGISTER_.*_TOKEN_BRIDGE_VAA" | grep -v SUI | cut -d '=' -f1) + +# 3. use 'worm' to submit each registration VAA +for VAA in $VAAS +do + VAA=${!VAA} + worm submit $VAA --chain sui --network devnet +done + +echo "Registrations successful." diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/scripts/setup_rust.sh b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/setup_rust.sh new file mode 100755 index 0000000000..3738ba9548 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/setup_rust.sh @@ -0,0 +1,3 @@ +#!/bin/bash + +curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/scripts/start_node.sh b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/start_node.sh new file mode 100755 index 0000000000..2ffce35438 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/start_node.sh @@ -0,0 +1,5 @@ +#!/bin/bash + +set -x + +sui start 2>&1 diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/scripts/switch.sh b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/switch.sh new file mode 100755 index 0000000000..caba0f4b70 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/switch.sh @@ -0,0 +1,31 @@ +#!/bin/bash + +network="$1" +valid_networks=("devnet" "testnet" "mainnet" "reset") + +usage() { + echo "Usage: $0 {devnet|testnet|mainnet|reset}" >&2 + exit 1 +} + +if [[ ! " ${valid_networks[@]} " =~ " ${network} " ]]; then + echo "Error: Unrecognized network '${network}'." + usage +fi + +git ls-files | grep 'Move.toml' | while read -r file; do + if [[ "$network" == "reset" ]]; then + echo "Resetting $file" + git checkout "$file" --quiet + else + dir=$(dirname "$file") + base=$(basename "$file") + new_file="${dir}/Move.$network.toml" + if [ -f "$new_file" ]; then + echo "Switching $file to $new_file" + rm "$file" + # Create a relative symlink + (cd "$dir" && ln -s "$(basename "$new_file")" "$base") + fi + fi +done diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/scripts/wait_for_devnet.sh b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/wait_for_devnet.sh new file mode 100755 index 0000000000..ff0b00355e --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/scripts/wait_for_devnet.sh @@ -0,0 +1,6 @@ +#!/bin/bash + +set -e + +# Wait for sui to start +while [[ "$(curl -X POST -H "Content-Type: application/json" -d '{ "jsonrpc":"2.0", "method":"rpc.discover","id":1 }' -s -o /dev/null -w '%{http_code}' 0.0.0.0:9000/)" != "200" ]]; do sleep 1; done diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/.gitignore b/target_chains/iota/vendor/wormhole_iota_testnet/testing/.gitignore new file mode 100644 index 0000000000..b552b7394c --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/.gitignore @@ -0,0 +1,4 @@ +node_modules +sui.log.* +./token_bridge/ +./wormhole/ diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/Makefile b/target_chains/iota/vendor/wormhole_iota_testnet/testing/Makefile new file mode 100644 index 0000000000..60c5246198 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/Makefile @@ -0,0 +1,13 @@ +-include ../Makefile.help + +.PHONY: clean +clean: + rm -rf node_modules + +node_modules: + pnpm i + +.PHONY: test +## Run tests +test: node_modules + bash run_integration_test.sh diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/00_environment.ts b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/00_environment.ts new file mode 100644 index 0000000000..3ca09f236d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/00_environment.ts @@ -0,0 +1,78 @@ +import { expect } from "chai"; +import * as mock from "@certusone/wormhole-sdk/lib/cjs/mock"; + +import { + CREATOR_PRIVATE_KEY, + GUARDIAN_PRIVATE_KEY, + RELAYER_PRIVATE_KEY, + WALLET_PRIVATE_KEY, +} from "./helpers/consts"; +import { + Ed25519Keypair, + JsonRpcProvider, + localnetConnection, + RawSigner, +} from "@mysten/sui.js"; + +describe(" 0. Environment", () => { + const provider = new JsonRpcProvider(localnetConnection); + + // User wallet. + const wallet = new RawSigner( + Ed25519Keypair.fromSecretKey(WALLET_PRIVATE_KEY), + provider + ); + + // Relayer wallet. + const relayer = new RawSigner( + Ed25519Keypair.fromSecretKey(RELAYER_PRIVATE_KEY), + provider + ); + + // Deployer wallet. + const creator = new RawSigner( + Ed25519Keypair.fromSecretKey(CREATOR_PRIVATE_KEY), + provider + ); + + describe("Verify Local Validator", () => { + it("Balance", async () => { + // Balance check wallet. + { + const coinData = await wallet + .getAddress() + .then((owner) => + provider + .getCoins({ owner, coinType: "0x2::sui::SUI" }) + .then((result) => result.data) + ); + expect(coinData).has.length(5); + } + + // Balance check relayer. + { + const coinData = await relayer + .getAddress() + .then((owner) => + provider + .getCoins({ owner, coinType: "0x2::sui::SUI" }) + .then((result) => result.data) + ); + expect(coinData).has.length(5); + } + + // Balance check creator. This should only have one gas object at this + // point. + { + const coinData = await creator + .getAddress() + .then((owner) => + provider + .getCoins({ owner, coinType: "0x2::sui::SUI" }) + .then((result) => result.data) + ); + expect(coinData).has.length(1); + } + }); + }); +}); diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/01_wormhole.ts b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/01_wormhole.ts new file mode 100644 index 0000000000..ae9a26f08b --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/01_wormhole.ts @@ -0,0 +1,109 @@ +import { expect } from "chai"; + +import { WALLET_PRIVATE_KEY, WORMHOLE_STATE_ID } from "./helpers/consts"; +import { + Ed25519Keypair, + JsonRpcProvider, + localnetConnection, + RawSigner, + SUI_CLOCK_OBJECT_ID, + TransactionBlock, +} from "@mysten/sui.js"; +import { getPackageId } from "./helpers/utils"; +import { addPrepareMessageAndPublishMessage } from "./helpers/wormhole/testPublishMessage"; + +describe(" 1. Wormhole", () => { + const provider = new JsonRpcProvider(localnetConnection); + + // User wallet. + const wallet = new RawSigner( + Ed25519Keypair.fromSecretKey(WALLET_PRIVATE_KEY), + provider + ); + + describe("Publish Message", () => { + it("Check `WormholeMessage` Event", async () => { + const wormholePackage = await getPackageId( + wallet.provider, + WORMHOLE_STATE_ID + ); + + const owner = await wallet.getAddress(); + + // Create emitter cap. + const emitterCapId = await (async () => { + const tx = new TransactionBlock(); + const [emitterCap] = tx.moveCall({ + target: `${wormholePackage}::emitter::new`, + arguments: [tx.object(WORMHOLE_STATE_ID)], + }); + tx.transferObjects([emitterCap], tx.pure(owner)); + + // Execute and fetch created Emitter cap. + return wallet + .signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showObjectChanges: true, + }, + }) + .then((result) => { + const found = result.objectChanges?.filter( + (item) => "created" === item.type! + ); + if (found?.length == 1 && "objectId" in found[0]) { + return found[0].objectId; + } + + throw new Error("no objects found"); + }); + })(); + + // Publish messages using emitter cap. + { + const nonce = 69; + const basePayload = "All your base are belong to us."; + + const numMessages = 32; + const payloads: string[] = []; + const tx = new TransactionBlock(); + + // Construct transaction block to send multiple messages. + for (let i = 0; i < numMessages; ++i) { + // Make a unique message. + const payload = basePayload + `... ${i}`; + payloads.push(payload); + + addPrepareMessageAndPublishMessage( + tx, + wormholePackage, + WORMHOLE_STATE_ID, + emitterCapId, + nonce, + payload + ); + } + + const events = await wallet + .signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEvents: true, + }, + }) + .then((result) => result.events!); + expect(events).has.length(numMessages); + + for (let i = 0; i < numMessages; ++i) { + const eventData = events[i].parsedJson!; + expect(eventData.consistency_level).equals(0); + expect(eventData.nonce).equals(nonce); + expect(eventData.payload).deep.equals([...Buffer.from(payloads[i])]); + expect(eventData.sender).equals(emitterCapId); + expect(eventData.sequence).equals(i.toString()); + expect(BigInt(eventData.timestamp) > 0n).is.true; + } + } + }); + }); +}); diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/build.ts b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/build.ts new file mode 100644 index 0000000000..374831ab8f --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/build.ts @@ -0,0 +1,32 @@ +import { fromB64, normalizeSuiObjectId } from "@mysten/sui.js"; +import { execSync, ExecSyncOptionsWithStringEncoding } from "child_process"; +import { UTF8 } from "./consts"; + +export const EXEC_UTF8: ExecSyncOptionsWithStringEncoding = { encoding: UTF8 }; + +export function buildForBytecode(packagePath: string) { + const buildOutput: { + modules: string[]; + dependencies: string[]; + } = JSON.parse( + execSync( + `sui move build --dump-bytecode-as-base64 -p ${packagePath} 2> /dev/null`, + EXEC_UTF8 + ) + ); + return { + modules: buildOutput.modules.map((m: string) => Array.from(fromB64(m))), + dependencies: buildOutput.dependencies.map((d: string) => + normalizeSuiObjectId(d) + ), + }; +} + +export function buildForDigest(packagePath: string) { + const digest = execSync( + `sui move build --dump-package-digest -p ${packagePath} 2> /dev/null`, + EXEC_UTF8 + ).substring(0, 64); + + return Buffer.from(digest, "hex"); +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/consts.ts b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/consts.ts new file mode 100644 index 0000000000..c4aa0787f4 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/consts.ts @@ -0,0 +1,40 @@ +// NOTE: modify these to reflect current versions of packages +export const VERSION_WORMHOLE = 1; +export const VERSION_TOKEN_BRIDGE = 1; + +// keystore +export const KEYSTORE = [ + "AB522qKKEsXMTFRD2SG3Het/02S/ZBOugmcH3R1CDG6l", + "AOmPq9B16F3W3ijO/4s9hI6v8LdiYCawKAW31PKpg4Qp", + "AGA20wtGcwbcNAG4nwapbQ5wIuXwkYQEWFUoSVAxctHb", +]; + +// wallets +export const WALLET_PRIVATE_KEY = Buffer.from(KEYSTORE[0], "base64").subarray( + 1 +); +export const RELAYER_PRIVATE_KEY = Buffer.from(KEYSTORE[1], "base64").subarray( + 1 +); +export const CREATOR_PRIVATE_KEY = Buffer.from(KEYSTORE[2], "base64").subarray( + 1 +); + +// guardian signer +export const GUARDIAN_PRIVATE_KEY = + "cfb12303a19cde580bb4dd771639b0d26bc68353645571a8cff516ab2ee113a0"; + +// wormhole +export const WORMHOLE_STATE_ID = + "0xc561a02a143575e53b87ba6c1476f053a307eac5179cb1c8121a3d3b220b81c1"; + +// token bridge +export const TOKEN_BRIDGE_STATE_ID = + "0x1c8de839f6331f2d745eb53b1b595bc466b4001c11617b0b66214b2e25ee72fc"; + +// governance +export const GOVERNANCE_EMITTER = + "0000000000000000000000000000000000000000000000000000000000000004"; + +// file encoding +export const UTF8: BufferEncoding = "utf-8"; diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/error/moveAbort.ts b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/error/moveAbort.ts new file mode 100644 index 0000000000..04fdde7524 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/error/moveAbort.ts @@ -0,0 +1,42 @@ +export function parseMoveAbort(errorMessage: string) { + const parsed = errorMessage.matchAll( + /MoveAbort\(MoveLocation { module: ModuleId { address: ([0-9a-f]{64}), name: Identifier\("([A-Za-z_]+)"\) }, function: ([0-9]+), instruction: ([0-9]+), function_name: Some\("([A-Za-z_]+)"\) }, ([0-9]+)\) in command ([0-9]+)/g + ); + + return parsed.next().value.slice(1, 8); +} + +export class MoveAbort { + packageId: string; + moduleName: string; + functionName: string; + errorCode: bigint; + command: number; + + constructor( + packageId: string, + moduleName: string, + functionName: string, + errorCode: string, + command: string + ) { + this.packageId = packageId; + this.moduleName = moduleName; + this.functionName = functionName; + this.errorCode = BigInt(errorCode); + this.command = Number(command); + } + + static parseError(errorMessage: string): MoveAbort { + const [packageId, moduleName, , , functionName, errorCode, command] = + parseMoveAbort(errorMessage); + + return new MoveAbort( + "0x" + packageId, + moduleName, + functionName, + errorCode, + command + ); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/error/wormhole.ts b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/error/wormhole.ts new file mode 100644 index 0000000000..f011d606df --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/error/wormhole.ts @@ -0,0 +1,22 @@ +import { MoveAbort } from "./moveAbort"; + +export function parseWormholeError(errorMessage: string) { + const abort = MoveAbort.parseError(errorMessage); + const code = abort.errorCode; + + switch (abort.moduleName) { + case "required_version": { + switch (code) { + case 0n: { + return "E_OUTDATED_VERSION"; + } + default: { + throw new Error(`unrecognized error code: ${abort}`); + } + } + } + default: { + throw new Error(`unrecognized module: ${abort}`); + } + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/setup.ts b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/setup.ts new file mode 100644 index 0000000000..0399be84e7 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/setup.ts @@ -0,0 +1,75 @@ +import * as fs from "fs"; +import * as mock from "@certusone/wormhole-sdk/lib/cjs/mock"; +import { GUARDIAN_PRIVATE_KEY, UTF8 } from "./consts"; + +export function generateVaaFromDigest( + digest: Buffer, + governance: mock.GovernanceEmitter +) { + const timestamp = 12345678; + const published = governance.publishWormholeUpgradeContract( + timestamp, + 2, + "0x" + digest.toString("hex") + ); + + // Sui is not supported yet by the SDK, so we need to adjust the payload. + published.writeUInt16BE(21, published.length - 34); + + // We will use the signed VAA when we execute the upgrade. + const guardians = new mock.MockGuardians(0, [GUARDIAN_PRIVATE_KEY]); + return guardians.addSignatures(published, [0]); +} + +export function modifyHardCodedVersionControl( + packagePath: string, + currentVersion: number, + newVersion: number +) { + const versionControlDotMove = `${packagePath}/sources/version_control.move`; + + const contents = fs.readFileSync(versionControlDotMove, UTF8); + const src = `const CURRENT_BUILD_VERSION: u64 = ${currentVersion}`; + if (contents.indexOf(src) < 0) { + throw new Error("current version not found"); + } + + const dst = `const CURRENT_BUILD_VERSION: u64 = ${newVersion}`; + fs.writeFileSync(versionControlDotMove, contents.replace(src, dst), UTF8); +} + +export function setUpWormholeDirectory( + srcWormholePath: string, + dstWormholePath: string +) { + fs.cpSync(srcWormholePath, dstWormholePath, { recursive: true }); + + // Remove irrelevant files. This part is not necessary, but is helpful + // for debugging a clean package directory. + const removeThese = [ + "Move.devnet.toml", + "Move.lock", + "Makefile", + "README.md", + "build", + ]; + for (const basename of removeThese) { + fs.rmSync(`${dstWormholePath}/${basename}`, { + recursive: true, + force: true, + }); + } + + // Fix Move.toml file. + const moveTomlPath = `${dstWormholePath}/Move.toml`; + const moveToml = fs.readFileSync(moveTomlPath, UTF8); + fs.writeFileSync( + moveTomlPath, + moveToml.replace(`wormhole = "_"`, `wormhole = "0x0"`), + UTF8 + ); +} + +export function cleanUpPackageDirectory(packagePath: string) { + fs.rmSync(packagePath, { recursive: true, force: true }); +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/upgrade.ts b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/upgrade.ts new file mode 100644 index 0000000000..4698e9a85b --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/upgrade.ts @@ -0,0 +1,73 @@ +import { + RawSigner, + SUI_CLOCK_OBJECT_ID, + TransactionBlock, +} from "@mysten/sui.js"; +import { buildForBytecode } from "./build"; +import { getPackageId } from "./utils"; + +export async function buildAndUpgradeWormhole( + signer: RawSigner, + signedVaa: Buffer, + wormholePath: string, + wormholeStateId: string +) { + const wormholePackage = await getPackageId(signer.provider, wormholeStateId); + + const tx = new TransactionBlock(); + + // Authorize upgrade. + const [upgradeTicket] = tx.moveCall({ + target: `${wormholePackage}::upgrade_contract::authorize_upgrade`, + arguments: [ + tx.object(wormholeStateId), + tx.pure(Array.from(signedVaa)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + // Build and generate modules and dependencies for upgrade. + const { modules, dependencies } = buildForBytecode(wormholePath); + const [upgradeReceipt] = tx.upgrade({ + modules, + dependencies, + packageId: wormholePackage, + ticket: upgradeTicket, + }); + + // Commit upgrade. + tx.moveCall({ + target: `${wormholePackage}::upgrade_contract::commit_upgrade`, + arguments: [tx.object(wormholeStateId), upgradeReceipt], + }); + + // Cannot auto compute gas budget, so we need to configure it manually. + // Gas ~215m. + tx.setGasBudget(215_000_000n); + + return signer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} + +export async function migrate(signer: RawSigner, stateId: string) { + const contractPackage = await getPackageId(signer.provider, stateId); + + const tx = new TransactionBlock(); + tx.moveCall({ + target: `${contractPackage}::migrate::migrate`, + arguments: [tx.object(stateId)], + }); + + return signer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/utils.ts b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/utils.ts new file mode 100644 index 0000000000..58f71444e1 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/utils.ts @@ -0,0 +1,27 @@ +import { JsonRpcProvider } from "@mysten/sui.js"; + +export async function getPackageId( + provider: JsonRpcProvider, + stateId: string +): Promise { + const state = await provider + .getObject({ + id: stateId, + options: { + showContent: true, + }, + }) + .then((result) => { + if (result.data?.content?.dataType == "moveObject") { + return result.data.content.fields; + } + + throw new Error("not move object"); + }); + + if ("upgrade_cap" in state) { + return state.upgrade_cap.fields.package; + } + + throw new Error("upgrade_cap not found"); +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/wormhole/testPublishMessage.ts b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/wormhole/testPublishMessage.ts new file mode 100644 index 0000000000..35a3876a51 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/js/helpers/wormhole/testPublishMessage.ts @@ -0,0 +1,31 @@ +import { SUI_CLOCK_OBJECT_ID, TransactionBlock } from "@mysten/sui.js"; + +export function addPrepareMessageAndPublishMessage( + tx: TransactionBlock, + wormholePackage: string, + wormholeStateId: string, + emitterCapId: string, + nonce: number, + payload: number[] | string +): TransactionBlock { + const [feeAmount] = tx.moveCall({ + target: `${wormholePackage}::state::message_fee`, + arguments: [tx.object(wormholeStateId)], + }); + const [wormholeFee] = tx.splitCoins(tx.gas, [feeAmount]); + const [messageTicket] = tx.moveCall({ + target: `${wormholePackage}::publish_message::prepare_message`, + arguments: [tx.object(emitterCapId), tx.pure(nonce), tx.pure(payload)], + }); + tx.moveCall({ + target: `${wormholePackage}::publish_message::publish_message`, + arguments: [ + tx.object(wormholeStateId), + wormholeFee, + messageTicket, + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + return tx; +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/package-lock.json b/target_chains/iota/vendor/wormhole_iota_testnet/testing/package-lock.json new file mode 100644 index 0000000000..3b6dd637e6 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/package-lock.json @@ -0,0 +1,5917 @@ +{ + "name": "wormhole-sui-integration-test", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "wormhole-sui-integration-test", + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "@certusone/wormhole-sdk": "^0.9.12", + "@mysten/sui.js": "^0.32.2", + "chai": "^4.3.7", + "mocha": "^10.2.0", + "prettier": "^2.8.7", + "ts-mocha": "^10.0.0", + "ts-node": "^10.9.1", + "typescript": "^5.0.4" + }, + "devDependencies": { + "@types/chai": "^4.3.4", + "@types/mocha": "^10.0.1", + "@types/node": "^18.15.11" + } + }, + "node_modules/@apollo/client": { + "version": "3.7.11", + "resolved": "https://registry.npmjs.org/@apollo/client/-/client-3.7.11.tgz", + "integrity": "sha512-uLg2KtxoAyj9ta7abLxXx8cGRM7HypCkXVmxtL7Ko//N5g37aoJ3ca7VYoFCMUFO1BXBulj+yKVl0U3+ILj5AQ==", + "license": "MIT", + "dependencies": { + "@graphql-typed-document-node/core": "^3.1.1", + "@wry/context": "^0.7.0", + "@wry/equality": "^0.5.0", + "@wry/trie": "^0.3.0", + "graphql-tag": "^2.12.6", + "hoist-non-react-statics": "^3.3.2", + "optimism": "^0.16.2", + "prop-types": "^15.7.2", + "response-iterator": "^0.2.6", + "symbol-observable": "^4.0.0", + "ts-invariant": "^0.10.3", + "tslib": "^2.3.0", + "zen-observable-ts": "^1.2.5" + }, + "peerDependencies": { + "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0", + "graphql-ws": "^5.5.5", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0", + "subscriptions-transport-ws": "^0.9.0 || ^0.11.0" + }, + "peerDependenciesMeta": { + "graphql-ws": { + "optional": true + }, + "react": { + "optional": true + }, + "react-dom": { + "optional": true + }, + "subscriptions-transport-ws": { + "optional": true + } + } + }, + "node_modules/@babel/runtime": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.21.0.tgz", + "integrity": "sha512-xwII0//EObnq89Ji5AKYQaRYiW/nZ3llSv29d49IuxPhKbtJoLP+9QUUZ4nVragQVtaVGeZrpB+ZtG/Pdy/POw==", + "license": "MIT", + "dependencies": { + "regenerator-runtime": "^0.13.11" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@certusone/wormhole-sdk": { + "version": "0.9.12", + "resolved": "https://registry.npmjs.org/@certusone/wormhole-sdk/-/wormhole-sdk-0.9.12.tgz", + "integrity": "sha512-ywMNc/tHg6qb9dcZLND1BMUISp7eFN+ksymOgjhwQcZZ/KUA/N1uVvbMVs0uSx+i0y4VloO9MwGc/uFnYKNsMQ==", + "license": "Apache-2.0", + "dependencies": { + "@certusone/wormhole-sdk-proto-web": "0.0.6", + "@certusone/wormhole-sdk-wasm": "^0.0.1", + "@coral-xyz/borsh": "0.2.6", + "@injectivelabs/networks": "^1.0.73", + "@injectivelabs/sdk-ts": "^1.0.368", + "@injectivelabs/utils": "^1.0.63", + "@project-serum/anchor": "^0.25.0", + "@solana/spl-token": "^0.3.5", + "@solana/web3.js": "^1.66.2", + "@terra-money/terra.js": "^3.1.3", + "@xpla/xpla.js": "^0.2.1", + "algosdk": "^1.15.0", + "aptos": "1.5.0", + "axios": "^0.24.0", + "bech32": "^2.0.0", + "binary-parser": "^2.2.1", + "bs58": "^4.0.1", + "elliptic": "^6.5.4", + "js-base64": "^3.6.1", + "near-api-js": "^1.0.0" + } + }, + "node_modules/@certusone/wormhole-sdk-proto-web": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/@certusone/wormhole-sdk-proto-web/-/wormhole-sdk-proto-web-0.0.6.tgz", + "integrity": "sha512-LTyjsrWryefx5WmkoBP6FQ2EjLxhMExAGxLkloHUhufVQZdrbGh0htBBUviP+HaDSJBCMPMtulNFwkBJV6muqQ==", + "license": "Apache-2.0", + "dependencies": { + "@improbable-eng/grpc-web": "^0.15.0", + "protobufjs": "^7.0.0", + "rxjs": "^7.5.6" + } + }, + "node_modules/@certusone/wormhole-sdk-proto-web/node_modules/@improbable-eng/grpc-web": { + "version": "0.15.0", + "resolved": "https://registry.npmjs.org/@improbable-eng/grpc-web/-/grpc-web-0.15.0.tgz", + "integrity": "sha512-ERft9/0/8CmYalqOVnJnpdDry28q+j+nAlFFARdjyxXDJ+Mhgv9+F600QC8BR9ygOfrXRlAk6CvST2j+JCpQPg==", + "license": "Apache-2.0", + "dependencies": { + "browser-headers": "^0.4.1" + }, + "peerDependencies": { + "google-protobuf": "^3.14.0" + } + }, + "node_modules/@certusone/wormhole-sdk-proto-web/node_modules/long": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/long/-/long-5.2.1.tgz", + "integrity": "sha512-GKSNGeNAtw8IryjjkhZxuKB3JzlcLTwjtiQCHKvqQet81I93kXslhDQruGI/QsddO83mcDToBVy7GqGS/zYf/A==", + "license": "Apache-2.0" + }, + "node_modules/@certusone/wormhole-sdk-proto-web/node_modules/protobufjs": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.2.3.tgz", + "integrity": "sha512-TtpvOqwB5Gdz/PQmOjgsrGH1nHjAQVCN7JG4A6r1sXRWESL5rNMAiRcBQlCAdKxZcAbstExQePYG8xof/JVRgg==", + "hasInstallScript": true, + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/node": ">=13.7.0", + "long": "^5.0.0" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@certusone/wormhole-sdk-wasm": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/@certusone/wormhole-sdk-wasm/-/wormhole-sdk-wasm-0.0.1.tgz", + "integrity": "sha512-LdIwLhOyr4pPs2jqYubqC7d4UkqYBX0EG/ppspQlW3qlVE0LZRMrH6oVzzLMyHtV0Rw7O9sIKzORW/T3mrJv2w==", + "license": "Apache-2.0", + "dependencies": { + "@types/long": "^4.0.2", + "@types/node": "^18.0.3" + } + }, + "node_modules/@certusone/wormhole-sdk/node_modules/axios": { + "version": "0.24.0", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.24.0.tgz", + "integrity": "sha512-Q6cWsys88HoPgAaFAVUb0WpPk0O8iTeisR9IMqy9G8AbO4NlpVknrnQS03zzF9PGAWgO3cgletO3VjV/P7VztA==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.14.4" + } + }, + "node_modules/@classic-terra/terra.proto": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@classic-terra/terra.proto/-/terra.proto-1.1.0.tgz", + "integrity": "sha512-bYhQG5LUaGF0KPRY9hYT/HEcd1QExZPQd6zLV/rQkCe/eDxfwFRLzZHpaaAdfWoAAZjsRWqJbUCqCg7gXBbJpw==", + "license": "Apache-2.0", + "dependencies": { + "@improbable-eng/grpc-web": "^0.14.1", + "google-protobuf": "^3.17.3", + "long": "^4.0.0", + "protobufjs": "~6.11.2" + } + }, + "node_modules/@confio/ics23": { + "version": "0.6.8", + "resolved": "https://registry.npmjs.org/@confio/ics23/-/ics23-0.6.8.tgz", + "integrity": "sha512-wB6uo+3A50m0sW/EWcU64xpV/8wShZ6bMTa7pF8eYsTrSkQA7oLUIJcs/wb8g4y2Oyq701BaGiO6n/ak5WXO1w==", + "license": "Apache-2.0", + "dependencies": { + "@noble/hashes": "^1.0.0", + "protobufjs": "^6.8.8" + } + }, + "node_modules/@coral-xyz/borsh": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/@coral-xyz/borsh/-/borsh-0.2.6.tgz", + "integrity": "sha512-y6nmHw1bFcJib7sMHsQPpC8r47xhqDZVvhUdna7NUPzpSbOZG6f46N21+aXsQ2w/tG8Ggls488J/ZmwbgVmyjg==", + "license": "Apache-2.0", + "dependencies": { + "bn.js": "^5.1.2", + "buffer-layout": "^1.2.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@solana/web3.js": "^1.2.0" + } + }, + "node_modules/@cosmjs/amino": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/amino/-/amino-0.30.1.tgz", + "integrity": "sha512-yNHnzmvAlkETDYIpeCTdVqgvrdt1qgkOXwuRVi8s27UKI5hfqyE9fJ/fuunXE6ZZPnKkjIecDznmuUOMrMvw4w==", + "license": "Apache-2.0", + "dependencies": { + "@cosmjs/crypto": "^0.30.1", + "@cosmjs/encoding": "^0.30.1", + "@cosmjs/math": "^0.30.1", + "@cosmjs/utils": "^0.30.1" + } + }, + "node_modules/@cosmjs/crypto": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/crypto/-/crypto-0.30.1.tgz", + "integrity": "sha512-rAljUlake3MSXs9xAm87mu34GfBLN0h/1uPPV6jEwClWjNkAMotzjC0ab9MARy5FFAvYHL3lWb57bhkbt2GtzQ==", + "license": "Apache-2.0", + "dependencies": { + "@cosmjs/encoding": "^0.30.1", + "@cosmjs/math": "^0.30.1", + "@cosmjs/utils": "^0.30.1", + "@noble/hashes": "^1", + "bn.js": "^5.2.0", + "elliptic": "^6.5.4", + "libsodium-wrappers": "^0.7.6" + } + }, + "node_modules/@cosmjs/encoding": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/encoding/-/encoding-0.30.1.tgz", + "integrity": "sha512-rXmrTbgqwihORwJ3xYhIgQFfMSrwLu1s43RIK9I8EBudPx3KmnmyAKzMOVsRDo9edLFNuZ9GIvysUCwQfq3WlQ==", + "license": "Apache-2.0", + "dependencies": { + "base64-js": "^1.3.0", + "bech32": "^1.1.4", + "readonly-date": "^1.0.0" + } + }, + "node_modules/@cosmjs/encoding/node_modules/bech32": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/bech32/-/bech32-1.1.4.tgz", + "integrity": "sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ==", + "license": "MIT" + }, + "node_modules/@cosmjs/json-rpc": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/json-rpc/-/json-rpc-0.30.1.tgz", + "integrity": "sha512-pitfC/2YN9t+kXZCbNuyrZ6M8abnCC2n62m+JtU9vQUfaEtVsgy+1Fk4TRQ175+pIWSdBMFi2wT8FWVEE4RhxQ==", + "license": "Apache-2.0", + "dependencies": { + "@cosmjs/stream": "^0.30.1", + "xstream": "^11.14.0" + } + }, + "node_modules/@cosmjs/math": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/math/-/math-0.30.1.tgz", + "integrity": "sha512-yaoeI23pin9ZiPHIisa6qqLngfnBR/25tSaWpkTm8Cy10MX70UF5oN4+/t1heLaM6SSmRrhk3psRkV4+7mH51Q==", + "license": "Apache-2.0", + "dependencies": { + "bn.js": "^5.2.0" + } + }, + "node_modules/@cosmjs/proto-signing": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/proto-signing/-/proto-signing-0.30.1.tgz", + "integrity": "sha512-tXh8pPYXV4aiJVhTKHGyeZekjj+K9s2KKojMB93Gcob2DxUjfKapFYBMJSgfKPuWUPEmyr8Q9km2hplI38ILgQ==", + "license": "Apache-2.0", + "dependencies": { + "@cosmjs/amino": "^0.30.1", + "@cosmjs/crypto": "^0.30.1", + "@cosmjs/encoding": "^0.30.1", + "@cosmjs/math": "^0.30.1", + "@cosmjs/utils": "^0.30.1", + "cosmjs-types": "^0.7.1", + "long": "^4.0.0" + } + }, + "node_modules/@cosmjs/socket": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/socket/-/socket-0.30.1.tgz", + "integrity": "sha512-r6MpDL+9N+qOS/D5VaxnPaMJ3flwQ36G+vPvYJsXArj93BjgyFB7BwWwXCQDzZ+23cfChPUfhbINOenr8N2Kow==", + "license": "Apache-2.0", + "dependencies": { + "@cosmjs/stream": "^0.30.1", + "isomorphic-ws": "^4.0.1", + "ws": "^7", + "xstream": "^11.14.0" + } + }, + "node_modules/@cosmjs/stargate": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/stargate/-/stargate-0.30.1.tgz", + "integrity": "sha512-RdbYKZCGOH8gWebO7r6WvNnQMxHrNXInY/gPHPzMjbQF6UatA6fNM2G2tdgS5j5u7FTqlCI10stNXrknaNdzog==", + "license": "Apache-2.0", + "dependencies": { + "@confio/ics23": "^0.6.8", + "@cosmjs/amino": "^0.30.1", + "@cosmjs/encoding": "^0.30.1", + "@cosmjs/math": "^0.30.1", + "@cosmjs/proto-signing": "^0.30.1", + "@cosmjs/stream": "^0.30.1", + "@cosmjs/tendermint-rpc": "^0.30.1", + "@cosmjs/utils": "^0.30.1", + "cosmjs-types": "^0.7.1", + "long": "^4.0.0", + "protobufjs": "~6.11.3", + "xstream": "^11.14.0" + } + }, + "node_modules/@cosmjs/stream": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/stream/-/stream-0.30.1.tgz", + "integrity": "sha512-Fg0pWz1zXQdoxQZpdHRMGvUH5RqS6tPv+j9Eh7Q953UjMlrwZVo0YFLC8OTf/HKVf10E4i0u6aM8D69Q6cNkgQ==", + "license": "Apache-2.0", + "dependencies": { + "xstream": "^11.14.0" + } + }, + "node_modules/@cosmjs/tendermint-rpc": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/tendermint-rpc/-/tendermint-rpc-0.30.1.tgz", + "integrity": "sha512-Z3nCwhXSbPZJ++v85zHObeUggrEHVfm1u18ZRwXxFE9ZMl5mXTybnwYhczuYOl7KRskgwlB+rID0WYACxj4wdQ==", + "license": "Apache-2.0", + "dependencies": { + "@cosmjs/crypto": "^0.30.1", + "@cosmjs/encoding": "^0.30.1", + "@cosmjs/json-rpc": "^0.30.1", + "@cosmjs/math": "^0.30.1", + "@cosmjs/socket": "^0.30.1", + "@cosmjs/stream": "^0.30.1", + "@cosmjs/utils": "^0.30.1", + "axios": "^0.21.2", + "readonly-date": "^1.0.0", + "xstream": "^11.14.0" + } + }, + "node_modules/@cosmjs/utils": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/utils/-/utils-0.30.1.tgz", + "integrity": "sha512-KvvX58MGMWh7xA+N+deCfunkA/ZNDvFLw4YbOmX3f/XBIkqrVY7qlotfy2aNb1kgp6h4B6Yc8YawJPDTfvWX7g==", + "license": "Apache-2.0" + }, + "node_modules/@cspotcode/source-map-support": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz", + "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==", + "dependencies": { + "@jridgewell/trace-mapping": "0.3.9" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@ethereumjs/common": { + "version": "2.6.5", + "resolved": "https://registry.npmjs.org/@ethereumjs/common/-/common-2.6.5.tgz", + "integrity": "sha512-lRyVQOeCDaIVtgfbowla32pzeDv2Obr8oR8Put5RdUBNRGr1VGPGQNGP6elWIpgK3YdpzqTOh4GyUGOureVeeA==", + "license": "MIT", + "dependencies": { + "crc-32": "^1.2.0", + "ethereumjs-util": "^7.1.5" + } + }, + "node_modules/@ethereumjs/tx": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/@ethereumjs/tx/-/tx-3.5.2.tgz", + "integrity": "sha512-gQDNJWKrSDGu2w7w0PzVXVBNMzb7wwdDOmOqczmhNjqFxFuIbhVJDwiGEnxFNC2/b8ifcZzY7MLcluizohRzNw==", + "license": "MPL-2.0", + "dependencies": { + "@ethereumjs/common": "^2.6.4", + "ethereumjs-util": "^7.1.5" + } + }, + "node_modules/@ethersproject/abi": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.7.0.tgz", + "integrity": "sha512-351ktp42TiRcYB3H1OP8yajPeAQstMW/yCFokj/AthP9bLHzQFPlOrxOcwYEDkUAICmOHljvN4K39OMTMUa9RA==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@ethersproject/abstract-provider": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abstract-provider/-/abstract-provider-5.7.0.tgz", + "integrity": "sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/networks": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/web": "^5.7.0" + } + }, + "node_modules/@ethersproject/abstract-signer": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abstract-signer/-/abstract-signer-5.7.0.tgz", + "integrity": "sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0" + } + }, + "node_modules/@ethersproject/address": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/address/-/address-5.7.0.tgz", + "integrity": "sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/rlp": "^5.7.0" + } + }, + "node_modules/@ethersproject/base64": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/base64/-/base64-5.7.0.tgz", + "integrity": "sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0" + } + }, + "node_modules/@ethersproject/basex": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/basex/-/basex-5.7.0.tgz", + "integrity": "sha512-ywlh43GwZLv2Voc2gQVTKBoVQ1mti3d8HK5aMxsfu/nRDnMmNqaSJ3r3n85HBByT8OpoY96SXM1FogC533T4zw==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/properties": "^5.7.0" + } + }, + "node_modules/@ethersproject/bignumber": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/bignumber/-/bignumber-5.7.0.tgz", + "integrity": "sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "bn.js": "^5.2.1" + } + }, + "node_modules/@ethersproject/bytes": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/bytes/-/bytes-5.7.0.tgz", + "integrity": "sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/constants": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.7.0.tgz", + "integrity": "sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bignumber": "^5.7.0" + } + }, + "node_modules/@ethersproject/contracts": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/contracts/-/contracts-5.7.0.tgz", + "integrity": "sha512-5GJbzEU3X+d33CdfPhcyS+z8MzsTrBGk/sc+G+59+tPa9yFkl6HQ9D6L0QMgNTA9q8dT0XKxxkyp883XsQvbbg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abi": "^5.7.0", + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/transactions": "^5.7.0" + } + }, + "node_modules/@ethersproject/hash": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.7.0.tgz", + "integrity": "sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/base64": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@ethersproject/hdnode": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/hdnode/-/hdnode-5.7.0.tgz", + "integrity": "sha512-OmyYo9EENBPPf4ERhR7oj6uAtUAhYGqOnIS+jE5pTXvdKBS99ikzq1E7Iv0ZQZ5V36Lqx1qZLeak0Ra16qpeOg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/basex": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/pbkdf2": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/sha2": "^5.7.0", + "@ethersproject/signing-key": "^5.7.0", + "@ethersproject/strings": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/wordlists": "^5.7.0" + } + }, + "node_modules/@ethersproject/json-wallets": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/json-wallets/-/json-wallets-5.7.0.tgz", + "integrity": "sha512-8oee5Xgu6+RKgJTkvEMl2wDgSPSAQ9MB/3JYjFV9jlKvcYHUXZC+cQp0njgmxdHkYWn8s6/IqIZYm0YWCjO/0g==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/hdnode": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/pbkdf2": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/random": "^5.7.0", + "@ethersproject/strings": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "aes-js": "3.0.0", + "scrypt-js": "3.0.1" + } + }, + "node_modules/@ethersproject/keccak256": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/keccak256/-/keccak256-5.7.0.tgz", + "integrity": "sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "js-sha3": "0.8.0" + } + }, + "node_modules/@ethersproject/logger": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.7.0.tgz", + "integrity": "sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT" + }, + "node_modules/@ethersproject/networks": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.7.1.tgz", + "integrity": "sha512-n/MufjFYv3yFcUyfhnXotyDlNdFb7onmkSy8aQERi2PjNcnWQ66xXxa3XlS8nCcA8aJKJjIIMNJTC7tu80GwpQ==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/pbkdf2": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/pbkdf2/-/pbkdf2-5.7.0.tgz", + "integrity": "sha512-oR/dBRZR6GTyaofd86DehG72hY6NpAjhabkhxgr3X2FpJtJuodEl2auADWBZfhDHgVCbu3/H/Ocq2uC6dpNjjw==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/sha2": "^5.7.0" + } + }, + "node_modules/@ethersproject/properties": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/properties/-/properties-5.7.0.tgz", + "integrity": "sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/providers": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.7.2.tgz", + "integrity": "sha512-g34EWZ1WWAVgr4aptGlVBF8mhl3VWjv+8hoAnzStu8Ah22VHBsuGzP17eb6xDVRzw895G4W7vvx60lFFur/1Rg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/base64": "^5.7.0", + "@ethersproject/basex": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/networks": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/random": "^5.7.0", + "@ethersproject/rlp": "^5.7.0", + "@ethersproject/sha2": "^5.7.0", + "@ethersproject/strings": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/web": "^5.7.0", + "bech32": "1.1.4", + "ws": "7.4.6" + } + }, + "node_modules/@ethersproject/providers/node_modules/bech32": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/bech32/-/bech32-1.1.4.tgz", + "integrity": "sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ==", + "license": "MIT" + }, + "node_modules/@ethersproject/providers/node_modules/ws": { + "version": "7.4.6", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.6.tgz", + "integrity": "sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A==", + "license": "MIT", + "engines": { + "node": ">=8.3.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/@ethersproject/random": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/random/-/random-5.7.0.tgz", + "integrity": "sha512-19WjScqRA8IIeWclFme75VMXSBvi4e6InrUNuaR4s5pTF2qNhcGdCUwdxUVGtDDqC00sDLCO93jPQoDUH4HVmQ==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/rlp": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/rlp/-/rlp-5.7.0.tgz", + "integrity": "sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/sha2": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/sha2/-/sha2-5.7.0.tgz", + "integrity": "sha512-gKlH42riwb3KYp0reLsFTokByAKoJdgFCwI+CCiX/k+Jm2mbNs6oOaCjYQSlI1+XBVejwH2KrmCbMAT/GnRDQw==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "hash.js": "1.1.7" + } + }, + "node_modules/@ethersproject/signing-key": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/signing-key/-/signing-key-5.7.0.tgz", + "integrity": "sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "bn.js": "^5.2.1", + "elliptic": "6.5.4", + "hash.js": "1.1.7" + } + }, + "node_modules/@ethersproject/solidity": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/solidity/-/solidity-5.7.0.tgz", + "integrity": "sha512-HmabMd2Dt/raavyaGukF4XxizWKhKQ24DoLtdNbBmNKUOPqwjsKQSdV9GQtj9CBEea9DlzETlVER1gYeXXBGaA==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/sha2": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@ethersproject/strings": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.7.0.tgz", + "integrity": "sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/transactions": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/transactions/-/transactions-5.7.0.tgz", + "integrity": "sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/rlp": "^5.7.0", + "@ethersproject/signing-key": "^5.7.0" + } + }, + "node_modules/@ethersproject/units": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/units/-/units-5.7.0.tgz", + "integrity": "sha512-pD3xLMy3SJu9kG5xDGI7+xhTEmGXlEqXU4OfNapmfnxLVY4EMSSRp7j1k7eezutBPH7RBN/7QPnwR7hzNlEFeg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/wallet": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/wallet/-/wallet-5.7.0.tgz", + "integrity": "sha512-MhmXlJXEJFBFVKrDLB4ZdDzxcBxQ3rLyCkhNqVu3CDYvR97E+8r01UgrI+TI99Le+aYm/in/0vp86guJuM7FCA==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/hdnode": "^5.7.0", + "@ethersproject/json-wallets": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/random": "^5.7.0", + "@ethersproject/signing-key": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/wordlists": "^5.7.0" + } + }, + "node_modules/@ethersproject/web": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/@ethersproject/web/-/web-5.7.1.tgz", + "integrity": "sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/base64": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@ethersproject/wordlists": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/wordlists/-/wordlists-5.7.0.tgz", + "integrity": "sha512-S2TFNJNfHWVHNE6cNDjbVlZ6MgE17MIxMbMg2zv3wn+3XSJGosL1m9ZVv3GXCf/2ymSsQ+hRI5IzoMJTG6aoVA==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@graphql-typed-document-node/core": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/@graphql-typed-document-node/core/-/core-3.2.0.tgz", + "integrity": "sha512-mB9oAsNCm9aM3/SOv4YtBMqZbYj10R7dkq8byBqxGY/ncFwhf2oQzMV+LCRlWoDSEBJ3COiR1yeDvMtsoOsuFQ==", + "license": "MIT", + "peerDependencies": { + "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0" + } + }, + "node_modules/@improbable-eng/grpc-web": { + "version": "0.14.1", + "resolved": "https://registry.npmjs.org/@improbable-eng/grpc-web/-/grpc-web-0.14.1.tgz", + "integrity": "sha512-XaIYuunepPxoiGVLLHmlnVminUGzBTnXr8Wv7khzmLWbNw4TCwJKX09GSMJlKhu/TRk6gms0ySFxewaETSBqgw==", + "license": "Apache-2.0", + "dependencies": { + "browser-headers": "^0.4.1" + }, + "peerDependencies": { + "google-protobuf": "^3.14.0" + } + }, + "node_modules/@injectivelabs/core-proto-ts": { + "version": "0.0.11", + "resolved": "https://registry.npmjs.org/@injectivelabs/core-proto-ts/-/core-proto-ts-0.0.11.tgz", + "integrity": "sha512-gYMzkoZ0olXLbEhSQVarUCMR6VAHytvENDv2Psjl9EjO5Pg93vTGLViS4E4vA5fezRfdF/x0Uic31w+ogp66jA==", + "license": "MIT", + "dependencies": { + "@injectivelabs/grpc-web": "^0.0.1", + "google-protobuf": "^3.14.0", + "protobufjs": "^7.0.0", + "rxjs": "^7.4.0" + } + }, + "node_modules/@injectivelabs/core-proto-ts/node_modules/long": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/long/-/long-5.2.1.tgz", + "integrity": "sha512-GKSNGeNAtw8IryjjkhZxuKB3JzlcLTwjtiQCHKvqQet81I93kXslhDQruGI/QsddO83mcDToBVy7GqGS/zYf/A==", + "license": "Apache-2.0" + }, + "node_modules/@injectivelabs/core-proto-ts/node_modules/protobufjs": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.2.3.tgz", + "integrity": "sha512-TtpvOqwB5Gdz/PQmOjgsrGH1nHjAQVCN7JG4A6r1sXRWESL5rNMAiRcBQlCAdKxZcAbstExQePYG8xof/JVRgg==", + "hasInstallScript": true, + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/node": ">=13.7.0", + "long": "^5.0.0" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@injectivelabs/exceptions": { + "version": "1.10.2", + "resolved": "https://registry.npmjs.org/@injectivelabs/exceptions/-/exceptions-1.10.2.tgz", + "integrity": "sha512-JLHgU/MjxRYSpn/9G9mJvHuNiA5ze6w86sXz09kQh7tlSaTC4PGqBBbBSu0hrUBBX86O+vk2ULkn1Ks1n7FlOw==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "@injectivelabs/grpc-web": "^0.0.1", + "@injectivelabs/ts-types": "^1.10.1", + "http-status-codes": "^2.2.0", + "link-module-alias": "^1.2.0", + "shx": "^0.3.2" + } + }, + "node_modules/@injectivelabs/exceptions/dist": { + "extraneous": true + }, + "node_modules/@injectivelabs/grpc-web": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/@injectivelabs/grpc-web/-/grpc-web-0.0.1.tgz", + "integrity": "sha512-Pu5YgaZp+OvR5UWfqbrPdHer3+gDf+b5fQoY+t2VZx1IAVHX8bzbN9EreYTvTYtFeDpYRWM8P7app2u4EX5wTw==", + "license": "Apache-2.0", + "dependencies": { + "browser-headers": "^0.4.1" + }, + "peerDependencies": { + "google-protobuf": "^3.14.0" + } + }, + "node_modules/@injectivelabs/grpc-web-node-http-transport": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/@injectivelabs/grpc-web-node-http-transport/-/grpc-web-node-http-transport-0.0.2.tgz", + "integrity": "sha512-rpyhXLiGY/UMs6v6YmgWHJHiO9l0AgDyVNv+jcutNVt4tQrmNvnpvz2wCAGOFtq5LuX/E9ChtTVpk3gWGqXcGA==", + "license": "Apache-2.0", + "peerDependencies": { + "@injectivelabs/grpc-web": ">=0.0.1" + } + }, + "node_modules/@injectivelabs/grpc-web-react-native-transport": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/@injectivelabs/grpc-web-react-native-transport/-/grpc-web-react-native-transport-0.0.2.tgz", + "integrity": "sha512-mk+aukQXnYNgPsPnu3KBi+FD0ZHQpazIlaBZ2jNZG7QAVmxTWtv3R66Zoq99Wx2dnE946NsZBYAoa0K5oSjnow==", + "license": "Apache-2.0", + "peerDependencies": { + "@injectivelabs/grpc-web": ">=0.0.1" + } + }, + "node_modules/@injectivelabs/indexer-proto-ts": { + "version": "0.0.9", + "resolved": "https://registry.npmjs.org/@injectivelabs/indexer-proto-ts/-/indexer-proto-ts-0.0.9.tgz", + "integrity": "sha512-ZFTUKlHAY2WYnB9RPPf11nq7SNm7wcKFTmFTavTiHV8UvNEni7dCR3Un6U5Mo1qD0xHEsfoCDMdqGcIguliPMA==", + "license": "MIT", + "dependencies": { + "@injectivelabs/grpc-web": "^0.0.1", + "google-protobuf": "^3.14.0", + "protobufjs": "^7.0.0", + "rxjs": "^7.4.0" + } + }, + "node_modules/@injectivelabs/indexer-proto-ts/node_modules/long": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/long/-/long-5.2.1.tgz", + "integrity": "sha512-GKSNGeNAtw8IryjjkhZxuKB3JzlcLTwjtiQCHKvqQet81I93kXslhDQruGI/QsddO83mcDToBVy7GqGS/zYf/A==", + "license": "Apache-2.0" + }, + "node_modules/@injectivelabs/indexer-proto-ts/node_modules/protobufjs": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.2.3.tgz", + "integrity": "sha512-TtpvOqwB5Gdz/PQmOjgsrGH1nHjAQVCN7JG4A6r1sXRWESL5rNMAiRcBQlCAdKxZcAbstExQePYG8xof/JVRgg==", + "hasInstallScript": true, + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/node": ">=13.7.0", + "long": "^5.0.0" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@injectivelabs/mito-proto-ts": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@injectivelabs/mito-proto-ts/-/mito-proto-ts-1.0.2.tgz", + "integrity": "sha512-A/5Nf/RJiBRiwYNqH2K0nNrOuuVcYCebqgEt3btpDfQXcyaHIssjDmZOtmMT1M7P/enEVgDu0auxE7tsmSFijg==", + "license": "MIT", + "dependencies": { + "@injectivelabs/grpc-web": "^0.0.1", + "google-protobuf": "^3.14.0", + "protobufjs": "^7.0.0", + "rxjs": "^7.4.0" + } + }, + "node_modules/@injectivelabs/mito-proto-ts/node_modules/long": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/long/-/long-5.2.1.tgz", + "integrity": "sha512-GKSNGeNAtw8IryjjkhZxuKB3JzlcLTwjtiQCHKvqQet81I93kXslhDQruGI/QsddO83mcDToBVy7GqGS/zYf/A==", + "license": "Apache-2.0" + }, + "node_modules/@injectivelabs/mito-proto-ts/node_modules/protobufjs": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.2.3.tgz", + "integrity": "sha512-TtpvOqwB5Gdz/PQmOjgsrGH1nHjAQVCN7JG4A6r1sXRWESL5rNMAiRcBQlCAdKxZcAbstExQePYG8xof/JVRgg==", + "hasInstallScript": true, + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/node": ">=13.7.0", + "long": "^5.0.0" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@injectivelabs/networks": { + "version": "1.10.4", + "resolved": "https://registry.npmjs.org/@injectivelabs/networks/-/networks-1.10.4.tgz", + "integrity": "sha512-EjWdTXpU+j8YFikxiMacVhPK8dzamMD4czkrst7NfcMRoBCMNMrOp5lItF5GFq0BSx3xu/zfkb2+3wWTIdWUxQ==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "@injectivelabs/exceptions": "^1.10.2", + "@injectivelabs/ts-types": "^1.10.1", + "@injectivelabs/utils": "^1.10.2", + "link-module-alias": "^1.2.0", + "shx": "^0.3.2" + } + }, + "node_modules/@injectivelabs/networks/dist": { + "extraneous": true + }, + "node_modules/@injectivelabs/sdk-ts": { + "version": "1.10.37", + "resolved": "https://registry.npmjs.org/@injectivelabs/sdk-ts/-/sdk-ts-1.10.37.tgz", + "integrity": "sha512-+7LzC1iDiN3oT7PZ3yV2PchsrH1WQfS+tV8/geesi0EBKT4AW4v2Ur3OYhtDXvQia1zSxWJY9phS3iAmaBd9vQ==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "@apollo/client": "^3.5.8", + "@cosmjs/amino": "^0.30.1", + "@cosmjs/proto-signing": "^0.30.1", + "@cosmjs/stargate": "^0.30.1", + "@ethersproject/bytes": "^5.7.0", + "@injectivelabs/core-proto-ts": "^0.0.11", + "@injectivelabs/exceptions": "^1.10.2", + "@injectivelabs/grpc-web": "^0.0.1", + "@injectivelabs/grpc-web-node-http-transport": "^0.0.2", + "@injectivelabs/grpc-web-react-native-transport": "^0.0.2", + "@injectivelabs/indexer-proto-ts": "^0.0.9", + "@injectivelabs/mito-proto-ts": "1.0.2", + "@injectivelabs/networks": "^1.10.4", + "@injectivelabs/test-utils": "^1.10.1", + "@injectivelabs/token-metadata": "^1.10.17", + "@injectivelabs/ts-types": "^1.10.1", + "@injectivelabs/utils": "^1.10.2", + "@metamask/eth-sig-util": "^4.0.0", + "axios": "^0.27.2", + "bech32": "^2.0.0", + "bip39": "^3.0.4", + "cosmjs-types": "^0.7.1", + "eth-crypto": "^2.6.0", + "ethereumjs-util": "^7.1.4", + "ethers": "^5.7.2", + "google-protobuf": "^3.21.0", + "graphql": "^16.3.0", + "http-status-codes": "^2.2.0", + "js-sha3": "^0.8.0", + "jscrypto": "^1.0.3", + "keccak256": "^1.0.6", + "link-module-alias": "^1.2.0", + "rxjs": "^7.8.0", + "secp256k1": "^4.0.3", + "shx": "^0.3.2", + "snakecase-keys": "^5.4.1" + } + }, + "node_modules/@injectivelabs/sdk-ts/dist": { + "extraneous": true + }, + "node_modules/@injectivelabs/sdk-ts/node_modules/axios": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.27.2.tgz", + "integrity": "sha512-t+yRIyySRTp/wua5xEr+z1q60QmLq8ABsS5O9Me1AsE5dfKqgnCFzwiCZZ/cGNd1lq4/7akDWMxdhVlucjmnOQ==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.14.9", + "form-data": "^4.0.0" + } + }, + "node_modules/@injectivelabs/test-utils": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/@injectivelabs/test-utils/-/test-utils-1.10.1.tgz", + "integrity": "sha512-ULP3XJBZN8Muv0jVpo0rfUOD/CDlyg4rij6YuRpYhTg6P0wIlKq9dL36cZlylay+F+4HeLn9qB0D2Cr3+FrhPw==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "axios": "^0.21.1", + "bignumber.js": "^9.0.1", + "link-module-alias": "^1.2.0", + "shx": "^0.3.2", + "snakecase-keys": "^5.1.2", + "store2": "^2.12.0" + } + }, + "node_modules/@injectivelabs/test-utils/dist": { + "extraneous": true + }, + "node_modules/@injectivelabs/token-metadata": { + "version": "1.10.17", + "resolved": "https://registry.npmjs.org/@injectivelabs/token-metadata/-/token-metadata-1.10.17.tgz", + "integrity": "sha512-1TFZMs38B21Y0uzqxRuIHifmj6VrJCZLEJnjGuhzIfhtLqSB/ZtCf3JNAarujwwgj6xWb7vzqzqNpo+SIYKvwg==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "@injectivelabs/exceptions": "^1.10.2", + "@injectivelabs/networks": "^1.10.4", + "@injectivelabs/ts-types": "^1.10.1", + "@injectivelabs/utils": "^1.10.2", + "@types/lodash.values": "^4.3.6", + "copyfiles": "^2.4.1", + "jsonschema": "^1.4.0", + "link-module-alias": "^1.2.0", + "lodash": "^4.17.21", + "lodash.values": "^4.3.0", + "shx": "^0.3.2" + } + }, + "node_modules/@injectivelabs/token-metadata/dist": { + "extraneous": true + }, + "node_modules/@injectivelabs/ts-types": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/@injectivelabs/ts-types/-/ts-types-1.10.1.tgz", + "integrity": "sha512-gQQjcnRx2TjLmZDMV8IIkRvLtAzTPptJuWKwPCfSlCRKOIv7Eafzy2qFINUIkKDOeu/lZUtSykEsAIUBEmXqFg==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "link-module-alias": "^1.2.0", + "shx": "^0.3.2" + } + }, + "node_modules/@injectivelabs/ts-types/dist": { + "extraneous": true + }, + "node_modules/@injectivelabs/utils": { + "version": "1.10.2", + "resolved": "https://registry.npmjs.org/@injectivelabs/utils/-/utils-1.10.2.tgz", + "integrity": "sha512-XMO7RRbXs06cChr5Wezr0Dbl1Z9hq+ceB4Dn3qyulzupGepeivkoPTcyG4IdjOiwf7PnFeGQ/aVG3hr0rJI7dQ==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "@injectivelabs/exceptions": "^1.10.2", + "@injectivelabs/ts-types": "^1.10.1", + "axios": "^0.21.1", + "bignumber.js": "^9.0.1", + "http-status-codes": "^2.2.0", + "link-module-alias": "^1.2.0", + "shx": "^0.3.2", + "snakecase-keys": "^5.1.2", + "store2": "^2.12.0" + } + }, + "node_modules/@injectivelabs/utils/dist": { + "extraneous": true + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz", + "integrity": "sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.9", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz", + "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==", + "dependencies": { + "@jridgewell/resolve-uri": "^3.0.3", + "@jridgewell/sourcemap-codec": "^1.4.10" + } + }, + "node_modules/@metamask/eth-sig-util": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@metamask/eth-sig-util/-/eth-sig-util-4.0.1.tgz", + "integrity": "sha512-tghyZKLHZjcdlDqCA3gNZmLeR0XvOE9U1qoQO9ohyAZT6Pya+H9vkBPcsyXytmYLNgVoin7CKCmweo/R43V+tQ==", + "license": "ISC", + "dependencies": { + "ethereumjs-abi": "^0.6.8", + "ethereumjs-util": "^6.2.1", + "ethjs-util": "^0.1.6", + "tweetnacl": "^1.0.3", + "tweetnacl-util": "^0.15.1" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@metamask/eth-sig-util/node_modules/@types/bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@metamask/eth-sig-util/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "license": "MIT" + }, + "node_modules/@metamask/eth-sig-util/node_modules/ethereumjs-util": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-6.2.1.tgz", + "integrity": "sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw==", + "license": "MPL-2.0", + "dependencies": { + "@types/bn.js": "^4.11.3", + "bn.js": "^4.11.0", + "create-hash": "^1.1.2", + "elliptic": "^6.5.2", + "ethereum-cryptography": "^0.1.3", + "ethjs-util": "0.1.6", + "rlp": "^2.2.3" + } + }, + "node_modules/@mysten/bcs": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/@mysten/bcs/-/bcs-0.7.1.tgz", + "integrity": "sha512-wFPb8bkhwrbiStfZMV5rFM7J+umpke59/dNjDp+UYJKykNlW23LCk2ePyEUvGdb62HGJM1jyOJ8g4egE3OmdKA==", + "license": "Apache-2.0", + "dependencies": { + "bs58": "^5.0.0" + } + }, + "node_modules/@mysten/bcs/node_modules/base-x": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-4.0.0.tgz", + "integrity": "sha512-FuwxlW4H5kh37X/oW59pwTzzTKRzfrrQwhmyspRM7swOEZcHtDZSCt45U6oKgtuFE+WYPblePMVIPR4RZrh/hw==", + "license": "MIT" + }, + "node_modules/@mysten/bcs/node_modules/bs58": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-5.0.0.tgz", + "integrity": "sha512-r+ihvQJvahgYT50JD05dyJNKlmmSlMoOGwn1lCcEzanPglg7TxYjioQUYehQ9mAR/+hOSd2jRc/Z2y5UxBymvQ==", + "license": "MIT", + "dependencies": { + "base-x": "^4.0.0" + } + }, + "node_modules/@mysten/sui.js": { + "version": "0.32.2", + "resolved": "https://registry.npmjs.org/@mysten/sui.js/-/sui.js-0.32.2.tgz", + "integrity": "sha512-/Hm4xkGolJhqj8FvQr7QSHDTlxIvL52mtbOao9f75YjrBh7y1Uh9kbJSY7xiTF1NY9sv6p5hUVlYRJuM0Hvn9A==", + "license": "Apache-2.0", + "dependencies": { + "@mysten/bcs": "0.7.1", + "@noble/curves": "^1.0.0", + "@noble/hashes": "^1.3.0", + "@scure/bip32": "^1.3.0", + "@scure/bip39": "^1.2.0", + "@suchipi/femver": "^1.0.0", + "jayson": "^4.0.0", + "rpc-websockets": "^7.5.1", + "superstruct": "^1.0.3", + "tweetnacl": "^1.0.3" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/@noble/curves": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.0.0.tgz", + "integrity": "sha512-2upgEu0iLiDVDZkNLeFV2+ht0BAVgQnEmCk6JsOch9Rp8xfkMCbvbAZlA2pBHQc73dbl+vFOXfqkf4uemdn0bw==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT", + "dependencies": { + "@noble/hashes": "1.3.0" + } + }, + "node_modules/@noble/ed25519": { + "version": "1.7.3", + "resolved": "https://registry.npmjs.org/@noble/ed25519/-/ed25519-1.7.3.tgz", + "integrity": "sha512-iR8GBkDt0Q3GyaVcIu7mSsVIqnFbkbRzGLWlvhwunacoLwt4J3swfKhfaM6rN6WY+TBGoYT1GtT1mIh2/jGbRQ==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT" + }, + "node_modules/@noble/hashes": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.3.0.tgz", + "integrity": "sha512-ilHEACi9DwqJB0pw7kv+Apvh50jiiSyR/cQ3y4W7lOR5mhvn/50FLUfsnfJz0BDZtl/RR16kXvptiv6q1msYZg==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT" + }, + "node_modules/@noble/secp256k1": { + "version": "1.7.1", + "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-1.7.1.tgz", + "integrity": "sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT" + }, + "node_modules/@project-serum/anchor": { + "version": "0.25.0", + "resolved": "https://registry.npmjs.org/@project-serum/anchor/-/anchor-0.25.0.tgz", + "integrity": "sha512-E6A5Y/ijqpfMJ5psJvbw0kVTzLZFUcOFgs6eSM2M2iWE1lVRF18T6hWZVNl6zqZsoz98jgnNHtVGJMs+ds9A7A==", + "license": "(MIT OR Apache-2.0)", + "dependencies": { + "@project-serum/borsh": "^0.2.5", + "@solana/web3.js": "^1.36.0", + "base64-js": "^1.5.1", + "bn.js": "^5.1.2", + "bs58": "^4.0.1", + "buffer-layout": "^1.2.2", + "camelcase": "^5.3.1", + "cross-fetch": "^3.1.5", + "crypto-hash": "^1.3.0", + "eventemitter3": "^4.0.7", + "js-sha256": "^0.9.0", + "pako": "^2.0.3", + "snake-case": "^3.0.4", + "superstruct": "^0.15.4", + "toml": "^3.0.0" + }, + "engines": { + "node": ">=11" + } + }, + "node_modules/@project-serum/anchor/node_modules/superstruct": { + "version": "0.15.5", + "resolved": "https://registry.npmjs.org/superstruct/-/superstruct-0.15.5.tgz", + "integrity": "sha512-4AOeU+P5UuE/4nOUkmcQdW5y7i9ndt1cQd/3iUe+LTz3RxESf/W/5lg4B74HbDMMv8PHnPnGCQFH45kBcrQYoQ==", + "license": "MIT" + }, + "node_modules/@project-serum/borsh": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/@project-serum/borsh/-/borsh-0.2.5.tgz", + "integrity": "sha512-UmeUkUoKdQ7rhx6Leve1SssMR/Ghv8qrEiyywyxSWg7ooV7StdpPBhciiy5eB3T0qU1BXvdRNC8TdrkxK7WC5Q==", + "license": "Apache-2.0", + "dependencies": { + "bn.js": "^5.1.2", + "buffer-layout": "^1.2.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@solana/web3.js": "^1.2.0" + } + }, + "node_modules/@protobufjs/aspromise": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz", + "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/base64": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz", + "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/codegen": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz", + "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/eventemitter": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz", + "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/fetch": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz", + "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==", + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.1", + "@protobufjs/inquire": "^1.1.0" + } + }, + "node_modules/@protobufjs/float": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz", + "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/inquire": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz", + "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/path": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz", + "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/pool": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz", + "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/utf8": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz", + "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==", + "license": "BSD-3-Clause" + }, + "node_modules/@scure/base": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.1.1.tgz", + "integrity": "sha512-ZxOhsSyxYwLJj3pLZCefNitxsj093tb2vq90mp2txoYeBqbcjDjqFhyM8eUjq/uFm6zJ+mUuqxlS2FkuSY1MTA==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT" + }, + "node_modules/@scure/bip32": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@scure/bip32/-/bip32-1.3.0.tgz", + "integrity": "sha512-bcKpo1oj54hGholplGLpqPHRbIsnbixFtc06nwuNM5/dwSXOq/AAYoIBRsBmnZJSdfeNW5rnff7NTAz3ZCqR9Q==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT", + "dependencies": { + "@noble/curves": "~1.0.0", + "@noble/hashes": "~1.3.0", + "@scure/base": "~1.1.0" + } + }, + "node_modules/@scure/bip39": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.2.0.tgz", + "integrity": "sha512-SX/uKq52cuxm4YFXWFaVByaSHJh2w3BnokVSeUJVCv6K7WulT9u2BuNRBhuFl8vAuYnzx9bEu9WgpcNYTrYieg==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT", + "dependencies": { + "@noble/hashes": "~1.3.0", + "@scure/base": "~1.1.0" + } + }, + "node_modules/@solana/buffer-layout": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@solana/buffer-layout/-/buffer-layout-4.0.1.tgz", + "integrity": "sha512-E1ImOIAD1tBZFRdjeM4/pzTiTApC0AOBGwyAMS4fwIodCWArzJ3DWdoh8cKxeFM2fElkxBh2Aqts1BPC373rHA==", + "license": "MIT", + "dependencies": { + "buffer": "~6.0.3" + }, + "engines": { + "node": ">=5.10" + } + }, + "node_modules/@solana/buffer-layout-utils": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/@solana/buffer-layout-utils/-/buffer-layout-utils-0.2.0.tgz", + "integrity": "sha512-szG4sxgJGktbuZYDg2FfNmkMi0DYQoVjN2h7ta1W1hPrwzarcFLBq9UpX1UjNXsNpT9dn+chgprtWGioUAr4/g==", + "license": "Apache-2.0", + "dependencies": { + "@solana/buffer-layout": "^4.0.0", + "@solana/web3.js": "^1.32.0", + "bigint-buffer": "^1.1.5", + "bignumber.js": "^9.0.1" + }, + "engines": { + "node": ">= 10" + } + }, + "node_modules/@solana/spl-token": { + "version": "0.3.7", + "resolved": "https://registry.npmjs.org/@solana/spl-token/-/spl-token-0.3.7.tgz", + "integrity": "sha512-bKGxWTtIw6VDdCBngjtsGlKGLSmiu/8ghSt/IOYJV24BsymRbgq7r12GToeetpxmPaZYLddKwAz7+EwprLfkfg==", + "license": "Apache-2.0", + "dependencies": { + "@solana/buffer-layout": "^4.0.0", + "@solana/buffer-layout-utils": "^0.2.0", + "buffer": "^6.0.3" + }, + "engines": { + "node": ">=16" + }, + "peerDependencies": { + "@solana/web3.js": "^1.47.4" + } + }, + "node_modules/@solana/web3.js": { + "version": "1.75.0", + "resolved": "https://registry.npmjs.org/@solana/web3.js/-/web3.js-1.75.0.tgz", + "integrity": "sha512-rHQgdo1EWfb+nPUpHe4O7i8qJPELHKNR5PAZRK+a7XxiykqOfbaAlPt5boDWAGPnYbSv0ziWZv5mq9DlFaQCxg==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.12.5", + "@noble/ed25519": "^1.7.0", + "@noble/hashes": "^1.1.2", + "@noble/secp256k1": "^1.6.3", + "@solana/buffer-layout": "^4.0.0", + "agentkeepalive": "^4.2.1", + "bigint-buffer": "^1.1.5", + "bn.js": "^5.0.0", + "borsh": "^0.7.0", + "bs58": "^4.0.1", + "buffer": "6.0.3", + "fast-stable-stringify": "^1.0.0", + "jayson": "^3.4.4", + "node-fetch": "^2.6.7", + "rpc-websockets": "^7.5.1", + "superstruct": "^0.14.2" + } + }, + "node_modules/@solana/web3.js/node_modules/@types/node": { + "version": "12.20.55", + "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.55.tgz", + "integrity": "sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==", + "license": "MIT" + }, + "node_modules/@solana/web3.js/node_modules/jayson": { + "version": "3.7.0", + "resolved": "https://registry.npmjs.org/jayson/-/jayson-3.7.0.tgz", + "integrity": "sha512-tfy39KJMrrXJ+mFcMpxwBvFDetS8LAID93+rycFglIQM4kl3uNR3W4lBLE/FFhsoUCEox5Dt2adVpDm/XtebbQ==", + "license": "MIT", + "dependencies": { + "@types/connect": "^3.4.33", + "@types/node": "^12.12.54", + "@types/ws": "^7.4.4", + "commander": "^2.20.3", + "delay": "^5.0.0", + "es6-promisify": "^5.0.0", + "eyes": "^0.1.8", + "isomorphic-ws": "^4.0.1", + "json-stringify-safe": "^5.0.1", + "JSONStream": "^1.3.5", + "lodash": "^4.17.20", + "uuid": "^8.3.2", + "ws": "^7.4.5" + }, + "bin": { + "jayson": "bin/jayson.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@solana/web3.js/node_modules/superstruct": { + "version": "0.14.2", + "resolved": "https://registry.npmjs.org/superstruct/-/superstruct-0.14.2.tgz", + "integrity": "sha512-nPewA6m9mR3d6k7WkZ8N8zpTWfenFH3q9pA2PkuiZxINr9DKB2+40wEQf0ixn8VaGuJ78AB6iWOtStI+/4FKZQ==", + "license": "MIT" + }, + "node_modules/@suchipi/femver": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@suchipi/femver/-/femver-1.0.0.tgz", + "integrity": "sha512-bprE8+K5V+DPX7q2e2K57ImqNBdfGHDIWaGI5xHxZoxbKOuQZn4wzPiUxOAHnsUr3w3xHrWXwN7gnG/iIuEMIg==", + "license": "MIT" + }, + "node_modules/@terra-money/legacy.proto": { + "name": "@terra-money/terra.proto", + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/@terra-money/terra.proto/-/terra.proto-0.1.7.tgz", + "integrity": "sha512-NXD7f6pQCulvo6+mv6MAPzhOkUzRjgYVuHZE/apih+lVnPG5hDBU0rRYnOGGofwvKT5/jQoOENnFn/gioWWnyQ==", + "license": "Apache-2.0", + "dependencies": { + "google-protobuf": "^3.17.3", + "long": "^4.0.0", + "protobufjs": "~6.11.2" + } + }, + "node_modules/@terra-money/terra.js": { + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/@terra-money/terra.js/-/terra.js-3.1.8.tgz", + "integrity": "sha512-Cd/fh4MswT00fDGVckoZ0cm77EpIy4+CjSDO0RqZ3Qfp4CJBp7sWTLRNsyzUWjdYOT5iTx+1wOMCYbbyKo6LAw==", + "license": "MIT", + "dependencies": { + "@classic-terra/terra.proto": "^1.1.0", + "@terra-money/terra.proto": "^2.1.0", + "axios": "^0.27.2", + "bech32": "^2.0.0", + "bip32": "^2.0.6", + "bip39": "^3.0.3", + "bufferutil": "^4.0.3", + "decimal.js": "^10.2.1", + "jscrypto": "^1.0.1", + "readable-stream": "^3.6.0", + "secp256k1": "^4.0.2", + "tmp": "^0.2.1", + "utf-8-validate": "^5.0.5", + "ws": "^7.5.9" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@terra-money/terra.js/node_modules/axios": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.27.2.tgz", + "integrity": "sha512-t+yRIyySRTp/wua5xEr+z1q60QmLq8ABsS5O9Me1AsE5dfKqgnCFzwiCZZ/cGNd1lq4/7akDWMxdhVlucjmnOQ==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.14.9", + "form-data": "^4.0.0" + } + }, + "node_modules/@terra-money/terra.proto": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@terra-money/terra.proto/-/terra.proto-2.1.0.tgz", + "integrity": "sha512-rhaMslv3Rkr+QsTQEZs64FKA4QlfO0DfQHaR6yct/EovenMkibDEQ63dEL6yJA6LCaEQGYhyVB9JO9pTUA8ybw==", + "license": "Apache-2.0", + "dependencies": { + "@improbable-eng/grpc-web": "^0.14.1", + "google-protobuf": "^3.17.3", + "long": "^4.0.0", + "protobufjs": "~6.11.2" + } + }, + "node_modules/@tsconfig/node10": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz", + "integrity": "sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==" + }, + "node_modules/@tsconfig/node12": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz", + "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==" + }, + "node_modules/@tsconfig/node14": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz", + "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==" + }, + "node_modules/@tsconfig/node16": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.3.tgz", + "integrity": "sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ==" + }, + "node_modules/@types/bn.js": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.1.tgz", + "integrity": "sha512-qNrYbZqMx0uJAfKnKclPh+dTwK33KfLHYqtyODwd5HnXOjnkhc4qgn3BrK6RWyGZm5+sIFE7Q7Vz6QQtJB7w7g==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/chai": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.4.tgz", + "integrity": "sha512-KnRanxnpfpjUTqTCXslZSEdLfXExwgNxYPdiO2WGUj8+HDjFi8R3k5RVKPeSCzLjCcshCAtVO2QBbVuAV4kTnw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/connect": { + "version": "3.4.35", + "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.35.tgz", + "integrity": "sha512-cdeYyv4KWoEgpBISTxWvqYsVy444DOqehiF3fM3ne10AmJ62RSyNkUnxMJXHQWRQQX2eR94m5y1IZyDwBjV9FQ==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/json5": { + "version": "0.0.29", + "resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz", + "integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==", + "license": "MIT", + "optional": true + }, + "node_modules/@types/lodash": { + "version": "4.14.192", + "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.192.tgz", + "integrity": "sha512-km+Vyn3BYm5ytMO13k9KTp27O75rbQ0NFw+U//g+PX7VZyjCioXaRFisqSIJRECljcTv73G3i6BpglNGHgUQ5A==", + "license": "MIT" + }, + "node_modules/@types/lodash.values": { + "version": "4.3.7", + "resolved": "https://registry.npmjs.org/@types/lodash.values/-/lodash.values-4.3.7.tgz", + "integrity": "sha512-Moex9/sWxtKEa+BKiH5zvmhfcieDlcz4wRxMhO/oJ2qOKUdujoU6dQjUTxWA8jwEREpHXmiY4HCwNRpycW8JQA==", + "license": "MIT", + "dependencies": { + "@types/lodash": "*" + } + }, + "node_modules/@types/long": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/long/-/long-4.0.2.tgz", + "integrity": "sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA==", + "license": "MIT" + }, + "node_modules/@types/mocha": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.1.tgz", + "integrity": "sha512-/fvYntiO1GeICvqbQ3doGDIP97vWmvFt83GKguJ6prmQM2iXZfFcq6YE8KteFyRtX2/h5Hf91BYvPodJKFYv5Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "18.15.11", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.15.11.tgz", + "integrity": "sha512-E5Kwq2n4SbMzQOn6wnmBjuK9ouqlURrcZDVfbo9ftDDTFt3nk7ZKK4GMOzoYgnpQJKcxwQw+lGaBvvlMo0qN/Q==", + "license": "MIT" + }, + "node_modules/@types/pbkdf2": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@types/pbkdf2/-/pbkdf2-3.1.0.tgz", + "integrity": "sha512-Cf63Rv7jCQ0LaL8tNXmEyqTHuIJxRdlS5vMh1mj5voN4+QFhVZnlZruezqpWYDiJ8UTzhP0VmeLXCmBk66YrMQ==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/secp256k1": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/@types/secp256k1/-/secp256k1-4.0.3.tgz", + "integrity": "sha512-Da66lEIFeIz9ltsdMZcpQvmrmmoqrfju8pm1BH8WbYjZSwUgCwXLb9C+9XYogwBITnbsSaMdVPb2ekf7TV+03w==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/ws": { + "version": "7.4.7", + "resolved": "https://registry.npmjs.org/@types/ws/-/ws-7.4.7.tgz", + "integrity": "sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@wry/context": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/@wry/context/-/context-0.7.0.tgz", + "integrity": "sha512-LcDAiYWRtwAoSOArfk7cuYvFXytxfVrdX7yxoUmK7pPITLk5jYh2F8knCwS7LjgYL8u1eidPlKKV6Ikqq0ODqQ==", + "license": "MIT", + "dependencies": { + "tslib": "^2.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@wry/equality": { + "version": "0.5.3", + "resolved": "https://registry.npmjs.org/@wry/equality/-/equality-0.5.3.tgz", + "integrity": "sha512-avR+UXdSrsF2v8vIqIgmeTY0UR91UT+IyablCyKe/uk22uOJ8fusKZnH9JH9e1/EtLeNJBtagNmL3eJdnOV53g==", + "license": "MIT", + "dependencies": { + "tslib": "^2.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@wry/trie": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/@wry/trie/-/trie-0.3.2.tgz", + "integrity": "sha512-yRTyhWSls2OY/pYLfwff867r8ekooZ4UI+/gxot5Wj8EFwSf2rG+n+Mo/6LoLQm1TKA4GRj2+LCpbfS937dClQ==", + "license": "MIT", + "dependencies": { + "tslib": "^2.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@xpla/xpla.js": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@xpla/xpla.js/-/xpla.js-0.2.3.tgz", + "integrity": "sha512-Tfk7hCGWXtwr08reY3Pi6dmzIqFbzri9jcyzJdfNmdo4cN0PMwpRJuZZcPmtxiIUnNef3AN1E/6nJUD5MKniuA==", + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.6.1", + "@ethersproject/keccak256": "^5.6.1", + "@ethersproject/signing-key": "^5.6.2", + "@terra-money/legacy.proto": "npm:@terra-money/terra.proto@^0.1.7", + "@terra-money/terra.proto": "^2.1.0", + "axios": "^0.26.1", + "bech32": "^2.0.0", + "bip32": "^2.0.6", + "bip39": "^3.0.3", + "bufferutil": "^4.0.3", + "crypto-addr-codec": "^0.1.7", + "decimal.js": "^10.2.1", + "elliptic": "^6.5.4", + "ethereumjs-util": "^7.1.5", + "jscrypto": "^1.0.1", + "readable-stream": "^3.6.0", + "secp256k1": "^4.0.2", + "tmp": "^0.2.1", + "utf-8-validate": "^5.0.5", + "ws": "^7.5.8" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@xpla/xpla.js/node_modules/axios": { + "version": "0.26.1", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.26.1.tgz", + "integrity": "sha512-fPwcX4EvnSHuInCMItEhAGnaSEXRBjtzh9fOtsE6E1G6p7vl7edEeZe11QHf18+6+9gR5PbKV/sGKNaD8YaMeA==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.14.8" + } + }, + "node_modules/acorn": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.1.1.tgz", + "integrity": "sha512-add7dgA5ppRPxCFJoAGfMDi7PIBXq1RtGo7BhbLaxwrXPOmw8gq48Y9ozT01hUKy9byMjlR20EJhu5zlkErEkg==", + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-walk": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz", + "integrity": "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/aes-js": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-3.0.0.tgz", + "integrity": "sha512-H7wUZRn8WpTq9jocdxQ2c8x2sKo9ZVmzfRE13GiNJXfp7NcKYEdvl3vspKjXox6RIG2VtaRe4JFvxG4rqp2Zuw==", + "license": "MIT" + }, + "node_modules/agentkeepalive": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.3.0.tgz", + "integrity": "sha512-7Epl1Blf4Sy37j4v9f9FjICCh4+KAQOyXgHEwlyBiAQLbhKdq/i2QQU3amQalS/wPhdPzDXPL5DMR5bkn+YeWg==", + "license": "MIT", + "dependencies": { + "debug": "^4.1.0", + "depd": "^2.0.0", + "humanize-ms": "^1.2.1" + }, + "engines": { + "node": ">= 8.0.0" + } + }, + "node_modules/algo-msgpack-with-bigint": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/algo-msgpack-with-bigint/-/algo-msgpack-with-bigint-2.1.1.tgz", + "integrity": "sha512-F1tGh056XczEaEAqu7s+hlZUDWwOBT70Eq0lfMpBP2YguSQVyxRbprLq5rELXKQOyOaixTWYhMeMQMzP0U5FoQ==", + "license": "ISC", + "engines": { + "node": ">= 10" + } + }, + "node_modules/algosdk": { + "version": "1.24.1", + "resolved": "https://registry.npmjs.org/algosdk/-/algosdk-1.24.1.tgz", + "integrity": "sha512-9moZxdqeJ6GdE4N6fA/GlUP4LrbLZMYcYkt141J4Ss68OfEgH9qW0wBuZ3ZOKEx/xjc5bg7mLP2Gjg7nwrkmww==", + "license": "MIT", + "dependencies": { + "algo-msgpack-with-bigint": "^2.1.1", + "buffer": "^6.0.2", + "cross-fetch": "^3.1.5", + "hi-base32": "^0.5.1", + "js-sha256": "^0.9.0", + "js-sha3": "^0.8.0", + "js-sha512": "^0.8.0", + "json-bigint": "^1.0.0", + "tweetnacl": "^1.0.3", + "vlq": "^2.0.4" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/ansi-colors": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz", + "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "license": "ISC", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/aptos": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/aptos/-/aptos-1.5.0.tgz", + "integrity": "sha512-N7OuRtU7IYHkDkNx+4QS3g/QQGCp+36KzYn3oXPmT7Kttfuv+UKliQVdjy3cLmwd/DCQSh9ObTovwdxnHjUn0g==", + "license": "Apache-2.0", + "dependencies": { + "@noble/hashes": "1.1.3", + "@scure/bip39": "1.1.0", + "axios": "0.27.2", + "form-data": "4.0.0", + "tweetnacl": "1.0.3" + }, + "engines": { + "node": ">=11.0.0" + } + }, + "node_modules/aptos/node_modules/@noble/hashes": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.1.3.tgz", + "integrity": "sha512-CE0FCR57H2acVI5UOzIGSSIYxZ6v/HOhDR0Ro9VLyhnzLwx0o8W1mmgaqlEUx4049qJDlIBRztv5k+MM8vbO3A==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT" + }, + "node_modules/aptos/node_modules/@scure/bip39": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.1.0.tgz", + "integrity": "sha512-pwrPOS16VeTKg98dYXQyIjJEcWfz7/1YJIwxUEPFfQPtc86Ym/1sVgQ2RLoD43AazMk2l/unK4ITySSpW2+82w==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT", + "dependencies": { + "@noble/hashes": "~1.1.1", + "@scure/base": "~1.1.0" + } + }, + "node_modules/aptos/node_modules/@scure/bip39/node_modules/@noble/hashes": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.1.5.tgz", + "integrity": "sha512-LTMZiiLc+V4v1Yi16TD6aX2gmtKszNye0pQgbaLqkvhIqP7nVsSaJsWloGQjJfJ8offaoP5GtX3yY5swbcJxxQ==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT" + }, + "node_modules/aptos/node_modules/axios": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.27.2.tgz", + "integrity": "sha512-t+yRIyySRTp/wua5xEr+z1q60QmLq8ABsS5O9Me1AsE5dfKqgnCFzwiCZZ/cGNd1lq4/7akDWMxdhVlucjmnOQ==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.14.9", + "form-data": "^4.0.0" + } + }, + "node_modules/arg": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz", + "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==" + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "license": "Python-2.0" + }, + "node_modules/arrify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz", + "integrity": "sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/assertion-error": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz", + "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "license": "MIT" + }, + "node_modules/axios": { + "version": "0.21.4", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.21.4.tgz", + "integrity": "sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.14.0" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "license": "MIT" + }, + "node_modules/base-x": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-3.0.9.tgz", + "integrity": "sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ==", + "license": "MIT", + "dependencies": { + "safe-buffer": "^5.0.1" + } + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/bech32": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/bech32/-/bech32-2.0.0.tgz", + "integrity": "sha512-LcknSilhIGatDAsY1ak2I8VtGaHNhgMSYVxFrGLXv+xLHytaKZKcaUJJUE7qmBr7h33o5YQwP55pMI0xmkpJwg==", + "license": "MIT" + }, + "node_modules/big-integer": { + "version": "1.6.36", + "resolved": "https://registry.npmjs.org/big-integer/-/big-integer-1.6.36.tgz", + "integrity": "sha512-t70bfa7HYEA1D9idDbmuv7YbsbVkQ+Hp+8KFSul4aE5e/i1bjCNIRYJZlA8Q8p0r9T8cF/RVvwUgRA//FydEyg==", + "license": "Unlicense", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/bigint-buffer": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/bigint-buffer/-/bigint-buffer-1.1.5.tgz", + "integrity": "sha512-trfYco6AoZ+rKhKnxA0hgX0HAbVP/s808/EuDSe2JDzUnCp/xAsli35Orvk67UrTEcwuxZqYZDmfA2RXJgxVvA==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "bindings": "^1.3.0" + }, + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/bignumber.js": { + "version": "9.1.1", + "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.1.1.tgz", + "integrity": "sha512-pHm4LsMJ6lzgNGVfZHjMoO8sdoRhOzOH4MLmY65Jg70bpxCKu5iOHNJyfF6OyvYw7t8Fpf35RuzUyqnQsj8Vig==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/binary-extensions": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", + "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/binary-parser": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/binary-parser/-/binary-parser-2.2.1.tgz", + "integrity": "sha512-5ATpz/uPDgq5GgEDxTB4ouXCde7q2lqAQlSdBRQVl/AJnxmQmhIfyxJx+0MGu//D5rHQifkfGbWWlaysG0o9NA==", + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/bindings": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz", + "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==", + "license": "MIT", + "dependencies": { + "file-uri-to-path": "1.0.0" + } + }, + "node_modules/bip32": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/bip32/-/bip32-2.0.6.tgz", + "integrity": "sha512-HpV5OMLLGTjSVblmrtYRfFFKuQB+GArM0+XP8HGWfJ5vxYBqo+DesvJwOdC2WJ3bCkZShGf0QIfoIpeomVzVdA==", + "license": "MIT", + "dependencies": { + "@types/node": "10.12.18", + "bs58check": "^2.1.1", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "tiny-secp256k1": "^1.1.3", + "typeforce": "^1.11.5", + "wif": "^2.0.6" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/bip32/node_modules/@types/node": { + "version": "10.12.18", + "resolved": "https://registry.npmjs.org/@types/node/-/node-10.12.18.tgz", + "integrity": "sha512-fh+pAqt4xRzPfqA6eh3Z2y6fyZavRIumvjhaCL753+TVkGKGhpPeyrJG2JftD0T9q4GF00KjefsQ+PQNDdWQaQ==", + "license": "MIT" + }, + "node_modules/bip39": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/bip39/-/bip39-3.1.0.tgz", + "integrity": "sha512-c9kiwdk45Do5GL0vJMe7tS95VjCii65mYAH7DfWl3uW8AVzXKQVUm64i3hzVybBDMp9r7j9iNxR85+ul8MdN/A==", + "license": "ISC", + "dependencies": { + "@noble/hashes": "^1.2.0" + } + }, + "node_modules/bip66": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/bip66/-/bip66-1.1.5.tgz", + "integrity": "sha512-nemMHz95EmS38a26XbbdxIYj5csHd3RMP3H5bwQknX0WYHF01qhpufP42mLOwVICuH2JmhIhXiWs89MfUGL7Xw==", + "license": "MIT", + "optional": true, + "dependencies": { + "safe-buffer": "^5.0.1" + } + }, + "node_modules/blakejs": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/blakejs/-/blakejs-1.2.1.tgz", + "integrity": "sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==", + "license": "MIT" + }, + "node_modules/bn.js": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz", + "integrity": "sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==", + "license": "MIT" + }, + "node_modules/borsh": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/borsh/-/borsh-0.7.0.tgz", + "integrity": "sha512-CLCsZGIBCFnPtkNnieW/a8wmreDmfUtjU2m9yHrzPXIlNbqVs0AQrSatSG6vdNYUqdc83tkQi2eHfF98ubzQLA==", + "license": "Apache-2.0", + "dependencies": { + "bn.js": "^5.2.0", + "bs58": "^4.0.0", + "text-encoding-utf-8": "^1.0.2" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "license": "MIT", + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==", + "license": "MIT" + }, + "node_modules/browser-headers": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/browser-headers/-/browser-headers-0.4.1.tgz", + "integrity": "sha512-CA9hsySZVo9371qEHjHZtYxV2cFtVj5Wj/ZHi8ooEsrtm4vOnl9Y9HmyYWk9q+05d7K3rdoAE0j3MVEFVvtQtg==", + "license": "Apache-2.0" + }, + "node_modules/browser-stdout": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz", + "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==", + "license": "ISC" + }, + "node_modules/browserify-aes": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz", + "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", + "license": "MIT", + "dependencies": { + "buffer-xor": "^1.0.3", + "cipher-base": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.3", + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "node_modules/bs58": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-4.0.1.tgz", + "integrity": "sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==", + "license": "MIT", + "dependencies": { + "base-x": "^3.0.2" + } + }, + "node_modules/bs58check": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/bs58check/-/bs58check-2.1.2.tgz", + "integrity": "sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==", + "license": "MIT", + "dependencies": { + "bs58": "^4.0.0", + "create-hash": "^1.1.0", + "safe-buffer": "^5.1.2" + } + }, + "node_modules/buffer": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", + "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==" + }, + "node_modules/buffer-layout": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/buffer-layout/-/buffer-layout-1.2.2.tgz", + "integrity": "sha512-kWSuLN694+KTk8SrYvCqwP2WcgQjoRCiF5b4QDvkkz8EmgD+aWAIceGFKMIAdmF/pH+vpgNV3d3kAKorcdAmWA==", + "license": "MIT", + "engines": { + "node": ">=4.5" + } + }, + "node_modules/buffer-xor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", + "integrity": "sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==", + "license": "MIT" + }, + "node_modules/bufferutil": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/bufferutil/-/bufferutil-4.0.7.tgz", + "integrity": "sha512-kukuqc39WOHtdxtw4UScxF/WVnMFVSQVKhtx3AjZJzhd0RGZZldcrfSEbVsWWe6KNH253574cq5F+wpv0G9pJw==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "node-gyp-build": "^4.3.0" + }, + "engines": { + "node": ">=6.14.2" + } + }, + "node_modules/camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/capability": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/capability/-/capability-0.2.5.tgz", + "integrity": "sha512-rsJZYVCgXd08sPqwmaIqjAd5SUTfonV0z/gDJ8D6cN8wQphky1kkAYEqQ+hmDxTw7UihvBfjUVUSY+DBEe44jg==", + "license": "MIT" + }, + "node_modules/chai": { + "version": "4.3.7", + "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.7.tgz", + "integrity": "sha512-HLnAzZ2iupm25PlN0xFreAlBA5zaBSv3og0DdeGA4Ar6h6rJ3A0rolRUKJhSF2V10GZKDgWF/VmAEsNWjCRB+A==", + "license": "MIT", + "dependencies": { + "assertion-error": "^1.1.0", + "check-error": "^1.0.2", + "deep-eql": "^4.1.2", + "get-func-name": "^2.0.0", + "loupe": "^2.3.1", + "pathval": "^1.1.1", + "type-detect": "^4.0.5" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/chalk/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/check-error": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz", + "integrity": "sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/chokidar": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", + "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT", + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "node_modules/cliui": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", + "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", + "license": "ISC", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^7.0.0" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "license": "MIT" + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "license": "MIT", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "license": "MIT" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "license": "MIT" + }, + "node_modules/copyfiles": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/copyfiles/-/copyfiles-2.4.1.tgz", + "integrity": "sha512-fereAvAvxDrQDOXybk3Qu3dPbOoKoysFMWtkY3mv5BsL8//OSZVL5DCLYqgRfY5cWirgRzlC+WSrxp6Bo3eNZg==", + "license": "MIT", + "dependencies": { + "glob": "^7.0.5", + "minimatch": "^3.0.3", + "mkdirp": "^1.0.4", + "noms": "0.0.0", + "through2": "^2.0.1", + "untildify": "^4.0.0", + "yargs": "^16.1.0" + }, + "bin": { + "copyfiles": "copyfiles", + "copyup": "copyfiles" + } + }, + "node_modules/copyfiles/node_modules/mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "license": "MIT", + "bin": { + "mkdirp": "bin/cmd.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/core-util-is": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz", + "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==", + "license": "MIT" + }, + "node_modules/cosmjs-types": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cosmjs-types/-/cosmjs-types-0.7.2.tgz", + "integrity": "sha512-vf2uLyktjr/XVAgEq0DjMxeAWh1yYREe7AMHDKd7EiHVqxBPCaBS+qEEQUkXbR9ndnckqr1sUG8BQhazh4X5lA==", + "license": "Apache-2.0", + "dependencies": { + "long": "^4.0.0", + "protobufjs": "~6.11.2" + } + }, + "node_modules/crc-32": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz", + "integrity": "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==", + "license": "Apache-2.0", + "bin": { + "crc32": "bin/crc32.njs" + }, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/create-hash": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", + "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", + "license": "MIT", + "dependencies": { + "cipher-base": "^1.0.1", + "inherits": "^2.0.1", + "md5.js": "^1.3.4", + "ripemd160": "^2.0.1", + "sha.js": "^2.4.0" + } + }, + "node_modules/create-hmac": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", + "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", + "license": "MIT", + "dependencies": { + "cipher-base": "^1.0.3", + "create-hash": "^1.1.0", + "inherits": "^2.0.1", + "ripemd160": "^2.0.0", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "node_modules/create-require": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz", + "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==" + }, + "node_modules/cross-fetch": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/cross-fetch/-/cross-fetch-3.1.5.tgz", + "integrity": "sha512-lvb1SBsI0Z7GDwmuid+mU3kWVBwTVUbe7S0H52yaaAdQOXq2YktTCZdlAcNKFzE6QtRz0snpw9bNiPeOIkkQvw==", + "license": "MIT", + "dependencies": { + "node-fetch": "2.6.7" + } + }, + "node_modules/cross-fetch/node_modules/node-fetch": { + "version": "2.6.7", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz", + "integrity": "sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==", + "license": "MIT", + "dependencies": { + "whatwg-url": "^5.0.0" + }, + "engines": { + "node": "4.x || >=6.0.0" + }, + "peerDependencies": { + "encoding": "^0.1.0" + }, + "peerDependenciesMeta": { + "encoding": { + "optional": true + } + } + }, + "node_modules/crypto-addr-codec": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/crypto-addr-codec/-/crypto-addr-codec-0.1.7.tgz", + "integrity": "sha512-X4hzfBzNhy4mAc3UpiXEC/L0jo5E8wAa9unsnA8nNXYzXjCcGk83hfC5avJWCSGT8V91xMnAS9AKMHmjw5+XCg==", + "license": "MIT", + "dependencies": { + "base-x": "^3.0.8", + "big-integer": "1.6.36", + "blakejs": "^1.1.0", + "bs58": "^4.0.1", + "ripemd160-min": "0.0.6", + "safe-buffer": "^5.2.0", + "sha3": "^2.1.1" + } + }, + "node_modules/crypto-hash": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/crypto-hash/-/crypto-hash-1.3.0.tgz", + "integrity": "sha512-lyAZ0EMyjDkVvz8WOeVnuCPvKVBXcMv1l5SVqO1yC7PzTwrD/pPje/BIRbWhMoPe436U+Y2nD7f5bFx0kt+Sbg==", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "license": "MIT", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/debug/node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "license": "MIT" + }, + "node_modules/decamelize": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz", + "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/decimal.js": { + "version": "10.4.3", + "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.4.3.tgz", + "integrity": "sha512-VBBaLc1MgL5XpzgIP7ny5Z6Nx3UrRkIViUkPUdtl9aya5amy3De1gsUUSB1g3+3sExYNjCAsAznmukyxCb1GRA==", + "license": "MIT" + }, + "node_modules/deep-eql": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.3.tgz", + "integrity": "sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==", + "license": "MIT", + "dependencies": { + "type-detect": "^4.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/define-properties": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz", + "integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==", + "license": "MIT", + "dependencies": { + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/delay": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/delay/-/delay-5.0.0.tgz", + "integrity": "sha512-ReEBKkIfe4ya47wlPYf/gu5ib6yUG0/Aez0JQZQz94kiWtRQvZIQbTiehsnwHvLSWJnQdhVeqYue7Id1dKr0qw==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/diff": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz", + "integrity": "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/dot-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/dot-case/-/dot-case-3.0.4.tgz", + "integrity": "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==", + "license": "MIT", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/drbg.js": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/drbg.js/-/drbg.js-1.0.1.tgz", + "integrity": "sha512-F4wZ06PvqxYLFEZKkFxTDcns9oFNk34hvmJSEwdzsxVQ8YI5YaxtACgQatkYgv2VI2CFkUd2Y+xosPQnHv809g==", + "license": "MIT", + "optional": true, + "dependencies": { + "browserify-aes": "^1.0.6", + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/eccrypto": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/eccrypto/-/eccrypto-1.1.6.tgz", + "integrity": "sha512-d78ivVEzu7Tn0ZphUUaL43+jVPKTMPFGtmgtz1D0LrFn7cY3K8CdrvibuLz2AAkHBLKZtR8DMbB2ukRYFk987A==", + "hasInstallScript": true, + "license": "CC0-1.0", + "dependencies": { + "acorn": "7.1.1", + "elliptic": "6.5.4", + "es6-promise": "4.2.8", + "nan": "2.14.0" + }, + "optionalDependencies": { + "secp256k1": "3.7.1" + } + }, + "node_modules/eccrypto/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "license": "MIT", + "optional": true + }, + "node_modules/eccrypto/node_modules/nan": { + "version": "2.14.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.0.tgz", + "integrity": "sha512-INOFj37C7k3AfaNTtX8RhsTw7qRy7eLET14cROi9+5HAVbbHuIWUHEauBv5qT4Av2tWasiTY1Jw6puUNqRJXQg==", + "license": "MIT" + }, + "node_modules/eccrypto/node_modules/secp256k1": { + "version": "3.7.1", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-3.7.1.tgz", + "integrity": "sha512-1cf8sbnRreXrQFdH6qsg2H71Xw91fCCS9Yp021GnUNJzWJS/py96fS4lHbnTnouLp08Xj6jBoBB6V78Tdbdu5g==", + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "dependencies": { + "bindings": "^1.5.0", + "bip66": "^1.1.5", + "bn.js": "^4.11.8", + "create-hash": "^1.2.0", + "drbg.js": "^1.0.1", + "elliptic": "^6.4.1", + "nan": "^2.14.0", + "safe-buffer": "^5.1.2" + }, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/eccrypto/node_modules/secp256k1/node_modules/nan": { + "version": "2.17.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.17.0.tgz", + "integrity": "sha512-2ZTgtl0nJsO0KQCjEpxcIr5D+Yv90plTitZt9JBfQvVJDS5seMl3FOvsh3+9CoYWXf/1l5OaZzzF6nDm4cagaQ==", + "license": "MIT", + "optional": true + }, + "node_modules/elliptic": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz", + "integrity": "sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==", + "license": "MIT", + "dependencies": { + "bn.js": "^4.11.9", + "brorand": "^1.1.0", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.1", + "inherits": "^2.0.4", + "minimalistic-assert": "^1.0.1", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "node_modules/elliptic/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "license": "MIT" + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" + }, + "node_modules/error-polyfill": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/error-polyfill/-/error-polyfill-0.1.3.tgz", + "integrity": "sha512-XHJk60ufE+TG/ydwp4lilOog549iiQF2OAPhkk9DdiYWMrltz5yhDz/xnKuenNwP7gy3dsibssO5QpVhkrSzzg==", + "license": "MIT", + "dependencies": { + "capability": "^0.2.5", + "o3": "^1.0.3", + "u3": "^0.1.1" + } + }, + "node_modules/es6-promise": { + "version": "4.2.8", + "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.8.tgz", + "integrity": "sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==", + "license": "MIT" + }, + "node_modules/es6-promisify": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz", + "integrity": "sha512-C+d6UdsYDk0lMebHNR4S2NybQMMngAOnOwYBQjTOiv0MkoJMP0Myw2mgpDLBcpfCmRLxyFqYhS/CfOENq4SJhQ==", + "license": "MIT", + "dependencies": { + "es6-promise": "^4.0.3" + } + }, + "node_modules/escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eth-crypto": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/eth-crypto/-/eth-crypto-2.6.0.tgz", + "integrity": "sha512-GCX4ffFYRUGgnuWR5qxcZIRQJ1KEqPFiyXU9yVy7s6dtXIMlUXZQ2h+5ID6rFaOHWbpJbjfkC6YdhwtwRYCnug==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "7.20.13", + "@ethereumjs/tx": "3.5.2", + "@types/bn.js": "5.1.1", + "eccrypto": "1.1.6", + "ethereumjs-util": "7.1.5", + "ethers": "5.7.2", + "secp256k1": "5.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/pubkey" + } + }, + "node_modules/eth-crypto/node_modules/@babel/runtime": { + "version": "7.20.13", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.20.13.tgz", + "integrity": "sha512-gt3PKXs0DBoL9xCvOIIZ2NEqAGZqHjAnmVbfQtB620V0uReIQutpel14KcneZuer7UioY8ALKZ7iocavvzTNFA==", + "license": "MIT", + "dependencies": { + "regenerator-runtime": "^0.13.11" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/eth-crypto/node_modules/node-addon-api": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-5.1.0.tgz", + "integrity": "sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA==", + "license": "MIT" + }, + "node_modules/eth-crypto/node_modules/secp256k1": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-5.0.0.tgz", + "integrity": "sha512-TKWX8xvoGHrxVdqbYeZM9w+izTF4b9z3NhSaDkdn81btvuh+ivbIMGT/zQvDtTFWhRlThpoz6LEYTr7n8A5GcA==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "elliptic": "^6.5.4", + "node-addon-api": "^5.0.0", + "node-gyp-build": "^4.2.0" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "license": "MIT", + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/ethereumjs-abi": { + "version": "0.6.8", + "resolved": "https://registry.npmjs.org/ethereumjs-abi/-/ethereumjs-abi-0.6.8.tgz", + "integrity": "sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA==", + "license": "MIT", + "dependencies": { + "bn.js": "^4.11.8", + "ethereumjs-util": "^6.0.0" + } + }, + "node_modules/ethereumjs-abi/node_modules/@types/bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/ethereumjs-abi/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "license": "MIT" + }, + "node_modules/ethereumjs-abi/node_modules/ethereumjs-util": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-6.2.1.tgz", + "integrity": "sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw==", + "license": "MPL-2.0", + "dependencies": { + "@types/bn.js": "^4.11.3", + "bn.js": "^4.11.0", + "create-hash": "^1.1.2", + "elliptic": "^6.5.2", + "ethereum-cryptography": "^0.1.3", + "ethjs-util": "0.1.6", + "rlp": "^2.2.3" + } + }, + "node_modules/ethereumjs-util": { + "version": "7.1.5", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz", + "integrity": "sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==", + "license": "MPL-2.0", + "dependencies": { + "@types/bn.js": "^5.1.0", + "bn.js": "^5.1.2", + "create-hash": "^1.1.2", + "ethereum-cryptography": "^0.1.3", + "rlp": "^2.2.4" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/ethers": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-5.7.2.tgz", + "integrity": "sha512-wswUsmWo1aOK8rR7DIKiWSw9DbLWe6x98Jrn8wcTflTVvaXhAMaB5zGAXy0GYQEQp9iO1iSHWVyARQm11zUtyg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abi": "5.7.0", + "@ethersproject/abstract-provider": "5.7.0", + "@ethersproject/abstract-signer": "5.7.0", + "@ethersproject/address": "5.7.0", + "@ethersproject/base64": "5.7.0", + "@ethersproject/basex": "5.7.0", + "@ethersproject/bignumber": "5.7.0", + "@ethersproject/bytes": "5.7.0", + "@ethersproject/constants": "5.7.0", + "@ethersproject/contracts": "5.7.0", + "@ethersproject/hash": "5.7.0", + "@ethersproject/hdnode": "5.7.0", + "@ethersproject/json-wallets": "5.7.0", + "@ethersproject/keccak256": "5.7.0", + "@ethersproject/logger": "5.7.0", + "@ethersproject/networks": "5.7.1", + "@ethersproject/pbkdf2": "5.7.0", + "@ethersproject/properties": "5.7.0", + "@ethersproject/providers": "5.7.2", + "@ethersproject/random": "5.7.0", + "@ethersproject/rlp": "5.7.0", + "@ethersproject/sha2": "5.7.0", + "@ethersproject/signing-key": "5.7.0", + "@ethersproject/solidity": "5.7.0", + "@ethersproject/strings": "5.7.0", + "@ethersproject/transactions": "5.7.0", + "@ethersproject/units": "5.7.0", + "@ethersproject/wallet": "5.7.0", + "@ethersproject/web": "5.7.1", + "@ethersproject/wordlists": "5.7.0" + } + }, + "node_modules/ethjs-util": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/ethjs-util/-/ethjs-util-0.1.6.tgz", + "integrity": "sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w==", + "license": "MIT", + "dependencies": { + "is-hex-prefixed": "1.0.0", + "strip-hex-prefix": "1.0.0" + }, + "engines": { + "node": ">=6.5.0", + "npm": ">=3" + } + }, + "node_modules/eventemitter3": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz", + "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==", + "license": "MIT" + }, + "node_modules/evp_bytestokey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", + "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", + "license": "MIT", + "dependencies": { + "md5.js": "^1.3.4", + "safe-buffer": "^5.1.1" + } + }, + "node_modules/eyes": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/eyes/-/eyes-0.1.8.tgz", + "integrity": "sha512-GipyPsXO1anza0AOZdy69Im7hGFCNB7Y/NGjDlZGJ3GJJLtwNSb2vrzYrTYJRrRloVx7pl+bhUaTB8yiccPvFQ==", + "engines": { + "node": "> 0.1.90" + } + }, + "node_modules/fast-stable-stringify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fast-stable-stringify/-/fast-stable-stringify-1.0.0.tgz", + "integrity": "sha512-wpYMUmFu5f00Sm0cj2pfivpmawLZ0NKdviQ4w9zJeR8JVtOpOxHmLaJuj0vxvGqMJQWyP/COUkF75/57OKyRag==", + "license": "MIT" + }, + "node_modules/file-uri-to-path": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz", + "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==", + "license": "MIT" + }, + "node_modules/fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", + "license": "BSD-3-Clause", + "bin": { + "flat": "cli.js" + } + }, + "node_modules/follow-redirects": { + "version": "1.15.2", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz", + "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "license": "MIT", + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/form-data": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz", + "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==", + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "license": "ISC" + }, + "node_modules/function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "license": "MIT" + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "license": "ISC", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-func-name": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz", + "integrity": "sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/globalthis": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", + "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", + "license": "MIT", + "dependencies": { + "define-properties": "^1.1.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/google-protobuf": { + "version": "3.21.2", + "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.21.2.tgz", + "integrity": "sha512-3MSOYFO5U9mPGikIYCzK0SaThypfGgS6bHqrUGXG3DPHCrb+txNqeEcns1W0lkGfk0rCyNXm7xB9rMxnCiZOoA==", + "license": "(BSD-3-Clause AND Apache-2.0)" + }, + "node_modules/graphql": { + "version": "16.6.0", + "resolved": "https://registry.npmjs.org/graphql/-/graphql-16.6.0.tgz", + "integrity": "sha512-KPIBPDlW7NxrbT/eh4qPXz5FiFdL5UbaA0XUNz2Rp3Z3hqBSkbj0GVjwFDztsWVauZUWsbKHgMg++sk8UX0bkw==", + "license": "MIT", + "engines": { + "node": "^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0" + } + }, + "node_modules/graphql-tag": { + "version": "2.12.6", + "resolved": "https://registry.npmjs.org/graphql-tag/-/graphql-tag-2.12.6.tgz", + "integrity": "sha512-FdSNcu2QQcWnM2VNvSCCDCVS5PpPqpzgFT8+GXzqJuoDd0CBncxCY278u4mhRO7tMgo2JjgJA5aZ+nWSQ/Z+xg==", + "license": "MIT", + "dependencies": { + "tslib": "^2.1.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "graphql": "^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0" + } + }, + "node_modules/has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.1" + }, + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/has-property-descriptors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", + "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "license": "MIT", + "dependencies": { + "get-intrinsic": "^1.1.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hash-base": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.1.0.tgz", + "integrity": "sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.4", + "readable-stream": "^3.6.0", + "safe-buffer": "^5.2.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/hash.js": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz", + "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.1" + } + }, + "node_modules/he": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", + "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", + "license": "MIT", + "bin": { + "he": "bin/he" + } + }, + "node_modules/hi-base32": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/hi-base32/-/hi-base32-0.5.1.tgz", + "integrity": "sha512-EmBBpvdYh/4XxsnUybsPag6VikPYnN30td+vQk+GI3qpahVEG9+gTkG0aXVxTjBqQ5T6ijbWIu77O+C5WFWsnA==", + "license": "MIT" + }, + "node_modules/hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==", + "license": "MIT", + "dependencies": { + "hash.js": "^1.0.3", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "node_modules/hoist-non-react-statics": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz", + "integrity": "sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==", + "license": "BSD-3-Clause", + "dependencies": { + "react-is": "^16.7.0" + } + }, + "node_modules/http-errors": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.8.1.tgz", + "integrity": "sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g==", + "license": "MIT", + "dependencies": { + "depd": "~1.1.2", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": ">= 1.5.0 < 2", + "toidentifier": "1.0.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/http-errors/node_modules/depd": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz", + "integrity": "sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/http-status-codes": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/http-status-codes/-/http-status-codes-2.2.0.tgz", + "integrity": "sha512-feERVo9iWxvnejp3SEfm/+oNG517npqL2/PIA8ORjyOZjGC7TwCRQsZylciLS64i6pJ0wRYz3rkXLRwbtFa8Ng==", + "license": "MIT" + }, + "node_modules/humanize-ms": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz", + "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==", + "license": "MIT", + "dependencies": { + "ms": "^2.0.0" + } + }, + "node_modules/ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "license": "ISC", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/interpret": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz", + "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "license": "MIT", + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-core-module": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.11.0.tgz", + "integrity": "sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==", + "license": "MIT", + "dependencies": { + "has": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-hex-prefixed": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-hex-prefixed/-/is-hex-prefixed-1.0.0.tgz", + "integrity": "sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA==", + "license": "MIT", + "engines": { + "node": ">=6.5.0", + "npm": ">=3" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-unicode-supported": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz", + "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==", + "license": "MIT" + }, + "node_modules/isomorphic-ws": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/isomorphic-ws/-/isomorphic-ws-4.0.1.tgz", + "integrity": "sha512-BhBvN2MBpWTaSHdWRb/bwdZJ1WaehQ2L1KngkCkfLUGF0mAWAT1sQUQacEmQ0jXkFw/czDXPNQSL5u2/Krsz1w==", + "license": "MIT", + "peerDependencies": { + "ws": "*" + } + }, + "node_modules/jayson": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jayson/-/jayson-4.0.0.tgz", + "integrity": "sha512-v2RNpDCMu45fnLzSk47vx7I+QUaOsox6f5X0CUlabAFwxoP+8MfAY0NQRFwOEYXIxm8Ih5y6OaEa5KYiQMkyAA==", + "license": "MIT", + "dependencies": { + "@types/connect": "^3.4.33", + "@types/node": "^12.12.54", + "@types/ws": "^7.4.4", + "commander": "^2.20.3", + "delay": "^5.0.0", + "es6-promisify": "^5.0.0", + "eyes": "^0.1.8", + "isomorphic-ws": "^4.0.1", + "json-stringify-safe": "^5.0.1", + "JSONStream": "^1.3.5", + "uuid": "^8.3.2", + "ws": "^7.4.5" + }, + "bin": { + "jayson": "bin/jayson.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jayson/node_modules/@types/node": { + "version": "12.20.55", + "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.55.tgz", + "integrity": "sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==", + "license": "MIT" + }, + "node_modules/js-base64": { + "version": "3.7.5", + "resolved": "https://registry.npmjs.org/js-base64/-/js-base64-3.7.5.tgz", + "integrity": "sha512-3MEt5DTINKqfScXKfJFrRbxkrnk2AxPWGBL/ycjz4dK8iqiSJ06UxD8jh8xuh6p10TX4t2+7FsBYVxxQbMg+qA==", + "license": "BSD-3-Clause" + }, + "node_modules/js-sha256": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/js-sha256/-/js-sha256-0.9.0.tgz", + "integrity": "sha512-sga3MHh9sgQN2+pJ9VYZ+1LPwXOxuBJBA5nrR5/ofPfuiJBE2hnjsaN8se8JznOmGLN2p49Pe5U/ttafcs/apA==", + "license": "MIT" + }, + "node_modules/js-sha3": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz", + "integrity": "sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==", + "license": "MIT" + }, + "node_modules/js-sha512": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/js-sha512/-/js-sha512-0.8.0.tgz", + "integrity": "sha512-PWsmefG6Jkodqt+ePTvBZCSMFgN7Clckjd0O7su3I0+BW2QWUTJNzjktHsztGLhncP2h8mcF9V9Y2Ha59pAViQ==", + "license": "MIT" + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jscrypto": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/jscrypto/-/jscrypto-1.0.3.tgz", + "integrity": "sha512-lryZl0flhodv4SZHOqyb1bx5sKcJxj0VBo0Kzb4QMAg3L021IC9uGpl0RCZa+9KJwlRGSK2C80ITcwbe19OKLQ==", + "license": "MIT", + "bin": { + "jscrypto": "bin/cli.js" + } + }, + "node_modules/json-bigint": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz", + "integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==", + "license": "MIT", + "dependencies": { + "bignumber.js": "^9.0.0" + } + }, + "node_modules/json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==", + "license": "ISC" + }, + "node_modules/json5": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz", + "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==", + "license": "MIT", + "optional": true, + "dependencies": { + "minimist": "^1.2.0" + }, + "bin": { + "json5": "lib/cli.js" + } + }, + "node_modules/jsonparse": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", + "integrity": "sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==", + "engines": [ + "node >= 0.2.0" + ], + "license": "MIT" + }, + "node_modules/jsonschema": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/jsonschema/-/jsonschema-1.4.1.tgz", + "integrity": "sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/JSONStream": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz", + "integrity": "sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==", + "license": "(MIT OR Apache-2.0)", + "dependencies": { + "jsonparse": "^1.2.0", + "through": ">=2.2.7 <3" + }, + "bin": { + "JSONStream": "bin.js" + }, + "engines": { + "node": "*" + } + }, + "node_modules/keccak": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/keccak/-/keccak-3.0.3.tgz", + "integrity": "sha512-JZrLIAJWuZxKbCilMpNz5Vj7Vtb4scDG3dMXLOsbzBmQGyjwE61BbW7bJkfKKCShXiQZt3T6sBgALRtmd+nZaQ==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "node-addon-api": "^2.0.0", + "node-gyp-build": "^4.2.0", + "readable-stream": "^3.6.0" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/keccak256": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/keccak256/-/keccak256-1.0.6.tgz", + "integrity": "sha512-8GLiM01PkdJVGUhR1e6M/AvWnSqYS0HaERI+K/QtStGDGlSTx2B1zTqZk4Zlqu5TxHJNTxWAdP9Y+WI50OApUw==", + "license": "MIT", + "dependencies": { + "bn.js": "^5.2.0", + "buffer": "^6.0.3", + "keccak": "^3.0.2" + } + }, + "node_modules/libsodium": { + "version": "0.7.11", + "resolved": "https://registry.npmjs.org/libsodium/-/libsodium-0.7.11.tgz", + "integrity": "sha512-WPfJ7sS53I2s4iM58QxY3Inb83/6mjlYgcmZs7DJsvDlnmVUwNinBCi5vBT43P6bHRy01O4zsMU2CoVR6xJ40A==", + "license": "ISC" + }, + "node_modules/libsodium-wrappers": { + "version": "0.7.11", + "resolved": "https://registry.npmjs.org/libsodium-wrappers/-/libsodium-wrappers-0.7.11.tgz", + "integrity": "sha512-SrcLtXj7BM19vUKtQuyQKiQCRJPgbpauzl3s0rSwD+60wtHqSUuqcoawlMDheCJga85nKOQwxNYQxf/CKAvs6Q==", + "license": "ISC", + "dependencies": { + "libsodium": "^0.7.11" + } + }, + "node_modules/link-module-alias": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/link-module-alias/-/link-module-alias-1.2.0.tgz", + "integrity": "sha512-ahPjXepbSVKbahTB6LxR//VHm8HPfI+QQygCH+E82spBY4HR5VPJTvlhKBc9F7muVxnS6C1rRfoPOXAbWO/fyw==", + "license": "MIT", + "dependencies": { + "chalk": "^2.4.1" + }, + "bin": { + "link-module-alias": "index.js" + }, + "engines": { + "node": "> 8.0.0" + } + }, + "node_modules/link-module-alias/node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "license": "MIT", + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/link-module-alias/node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/link-module-alias/node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "license": "MIT", + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/link-module-alias/node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "license": "MIT" + }, + "node_modules/link-module-alias/node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "license": "MIT", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/link-module-alias/node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/link-module-alias/node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "license": "MIT", + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", + "license": "MIT" + }, + "node_modules/lodash.values": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/lodash.values/-/lodash.values-4.3.0.tgz", + "integrity": "sha512-r0RwvdCv8id9TUblb/O7rYPwVy6lerCbcawrfdo9iC/1t1wsNMJknO79WNBgwkH0hIeJ08jmvvESbFpNb4jH0Q==", + "license": "MIT" + }, + "node_modules/log-symbols": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", + "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==", + "license": "MIT", + "dependencies": { + "chalk": "^4.1.0", + "is-unicode-supported": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/long": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/long/-/long-4.0.0.tgz", + "integrity": "sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==", + "license": "Apache-2.0" + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "license": "MIT", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/loupe": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.6.tgz", + "integrity": "sha512-RaPMZKiMy8/JruncMU5Bt6na1eftNoo++R4Y+N2FrxkDVTrGvcyzFTsaGif4QTeKESheMGegbhw6iUAq+5A8zA==", + "license": "MIT", + "dependencies": { + "get-func-name": "^2.0.0" + } + }, + "node_modules/lower-case": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/lower-case/-/lower-case-2.0.2.tgz", + "integrity": "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==", + "license": "MIT", + "dependencies": { + "tslib": "^2.0.3" + } + }, + "node_modules/make-error": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", + "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==", + "license": "ISC" + }, + "node_modules/map-obj": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-4.3.0.tgz", + "integrity": "sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/md5.js": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz", + "integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==", + "license": "MIT", + "dependencies": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/minimalistic-assert": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", + "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==", + "license": "ISC" + }, + "node_modules/minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==", + "license": "MIT" + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/mkdirp": { + "version": "0.5.6", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz", + "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==", + "dependencies": { + "minimist": "^1.2.6" + }, + "bin": { + "mkdirp": "bin/cmd.js" + } + }, + "node_modules/mocha": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.2.0.tgz", + "integrity": "sha512-IDY7fl/BecMwFHzoqF2sg/SHHANeBoMMXFlS9r0OXKDssYE1M5O43wUY/9BVPeIvfH2zmEbBfseqN9gBQZzXkg==", + "license": "MIT", + "dependencies": { + "ansi-colors": "4.1.1", + "browser-stdout": "1.3.1", + "chokidar": "3.5.3", + "debug": "4.3.4", + "diff": "5.0.0", + "escape-string-regexp": "4.0.0", + "find-up": "5.0.0", + "glob": "7.2.0", + "he": "1.2.0", + "js-yaml": "4.1.0", + "log-symbols": "4.1.0", + "minimatch": "5.0.1", + "ms": "2.1.3", + "nanoid": "3.3.3", + "serialize-javascript": "6.0.0", + "strip-json-comments": "3.1.1", + "supports-color": "8.1.1", + "workerpool": "6.2.1", + "yargs": "16.2.0", + "yargs-parser": "20.2.4", + "yargs-unparser": "2.0.0" + }, + "bin": { + "_mocha": "bin/_mocha", + "mocha": "bin/mocha.js" + }, + "engines": { + "node": ">= 14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mochajs" + } + }, + "node_modules/mocha/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/mocha/node_modules/glob": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz", + "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==", + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/mocha/node_modules/glob/node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/mocha/node_modules/glob/node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/mocha/node_modules/minimatch": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz", + "integrity": "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==", + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/mustache": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/mustache/-/mustache-4.2.0.tgz", + "integrity": "sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==", + "license": "MIT", + "bin": { + "mustache": "bin/mustache" + } + }, + "node_modules/nan": { + "version": "2.17.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.17.0.tgz", + "integrity": "sha512-2ZTgtl0nJsO0KQCjEpxcIr5D+Yv90plTitZt9JBfQvVJDS5seMl3FOvsh3+9CoYWXf/1l5OaZzzF6nDm4cagaQ==", + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.3.tgz", + "integrity": "sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w==", + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/near-api-js": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/near-api-js/-/near-api-js-1.1.0.tgz", + "integrity": "sha512-qYKv1mYsaDZc2uYndhS+ttDhR9+60qFc+ZjD6lWsAxr3ZskMjRwPffDGQZYhC7BRDQMe1HEbk6d5mf+TVm0Lqg==", + "license": "(MIT AND Apache-2.0)", + "dependencies": { + "bn.js": "5.2.1", + "borsh": "^0.7.0", + "bs58": "^4.0.0", + "depd": "^2.0.0", + "error-polyfill": "^0.1.3", + "http-errors": "^1.7.2", + "js-sha256": "^0.9.0", + "mustache": "^4.0.0", + "node-fetch": "^2.6.1", + "text-encoding-utf-8": "^1.0.2", + "tweetnacl": "^1.0.1" + } + }, + "node_modules/no-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz", + "integrity": "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==", + "license": "MIT", + "dependencies": { + "lower-case": "^2.0.2", + "tslib": "^2.0.3" + } + }, + "node_modules/node-addon-api": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-2.0.2.tgz", + "integrity": "sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==", + "license": "MIT" + }, + "node_modules/node-fetch": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.9.tgz", + "integrity": "sha512-DJm/CJkZkRjKKj4Zi4BsKVZh3ValV5IR5s7LVZnW+6YMh0W1BfNA8XSs6DLMGYlId5F3KnA70uu2qepcR08Qqg==", + "license": "MIT", + "dependencies": { + "whatwg-url": "^5.0.0" + }, + "engines": { + "node": "4.x || >=6.0.0" + }, + "peerDependencies": { + "encoding": "^0.1.0" + }, + "peerDependenciesMeta": { + "encoding": { + "optional": true + } + } + }, + "node_modules/node-gyp-build": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.6.0.tgz", + "integrity": "sha512-NTZVKn9IylLwUzaKjkas1e4u2DLNcV4rdYagA4PWdPwW87Bi7z+BznyKSRwS/761tV/lzCGXplWsiaMjLqP2zQ==", + "license": "MIT", + "bin": { + "node-gyp-build": "bin.js", + "node-gyp-build-optional": "optional.js", + "node-gyp-build-test": "build-test.js" + } + }, + "node_modules/noms": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/noms/-/noms-0.0.0.tgz", + "integrity": "sha512-lNDU9VJaOPxUmXcLb+HQFeUgQQPtMI24Gt6hgfuMHRJgMRHMF/qZ4HJD3GDru4sSw9IQl2jPjAYnQrdIeLbwow==", + "license": "ISC", + "dependencies": { + "inherits": "^2.0.1", + "readable-stream": "~1.0.31" + } + }, + "node_modules/noms/node_modules/readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha512-ok1qVCJuRkNmvebYikljxJA/UEsKwLl2nI1OmaqAu4/UE+h0wKCHok4XkL/gvi39OacXvw59RJUOFUkDib2rHg==", + "license": "MIT", + "dependencies": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.1", + "isarray": "0.0.1", + "string_decoder": "~0.10.x" + } + }, + "node_modules/noms/node_modules/string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==", + "license": "MIT" + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/o3": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/o3/-/o3-1.0.3.tgz", + "integrity": "sha512-f+4n+vC6s4ysy7YO7O2gslWZBUu8Qj2i2OUJOvjRxQva7jVjYjB29jrr9NCjmxZQR0gzrOcv1RnqoYOeMs5VRQ==", + "license": "MIT", + "dependencies": { + "capability": "^0.2.5" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/optimism": { + "version": "0.16.2", + "resolved": "https://registry.npmjs.org/optimism/-/optimism-0.16.2.tgz", + "integrity": "sha512-zWNbgWj+3vLEjZNIh/okkY2EUfX+vB9TJopzIZwT1xxaMqC5hRLLraePod4c5n4He08xuXNH+zhKFFCu390wiQ==", + "license": "MIT", + "dependencies": { + "@wry/context": "^0.7.0", + "@wry/trie": "^0.3.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pako": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/pako/-/pako-2.1.0.tgz", + "integrity": "sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug==", + "license": "(MIT AND Zlib)" + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "license": "MIT" + }, + "node_modules/pathval": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz", + "integrity": "sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/pbkdf2": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.2.tgz", + "integrity": "sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==", + "license": "MIT", + "dependencies": { + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4", + "ripemd160": "^2.0.1", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + }, + "engines": { + "node": ">=0.12" + } + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/prettier": { + "version": "2.8.7", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.7.tgz", + "integrity": "sha512-yPngTo3aXUUmyuTjeTUT75txrf+aMh9FiD7q9ZE/i6r0bPb22g4FsE6Y338PQX1bmfy08i9QQCB7/rcUAVntfw==", + "license": "MIT", + "bin": { + "prettier": "bin-prettier.js" + }, + "engines": { + "node": ">=10.13.0" + }, + "funding": { + "url": "https://github.com/prettier/prettier?sponsor=1" + } + }, + "node_modules/process-nextick-args": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", + "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", + "license": "MIT" + }, + "node_modules/prop-types": { + "version": "15.8.1", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz", + "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + } + }, + "node_modules/protobufjs": { + "version": "6.11.3", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-6.11.3.tgz", + "integrity": "sha512-xL96WDdCZYdU7Slin569tFX712BxsxslWwAfAhCYjQKGTq7dAU91Lomy6nLLhh/dyGhk/YH4TwTSRxTzhuHyZg==", + "hasInstallScript": true, + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/long": "^4.0.1", + "@types/node": ">=13.7.0", + "long": "^4.0.0" + }, + "bin": { + "pbjs": "bin/pbjs", + "pbts": "bin/pbts" + } + }, + "node_modules/randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "license": "MIT", + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, + "node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==", + "license": "MIT" + }, + "node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "license": "MIT", + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/readonly-date": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/readonly-date/-/readonly-date-1.0.0.tgz", + "integrity": "sha512-tMKIV7hlk0h4mO3JTmmVuIlJVXjKk3Sep9Bf5OH0O+758ruuVkUy2J9SttDLm91IEX/WHlXPSpxMGjPj4beMIQ==", + "license": "Apache-2.0" + }, + "node_modules/rechoir": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz", + "integrity": "sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==", + "dependencies": { + "resolve": "^1.1.6" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/regenerator-runtime": { + "version": "0.13.11", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz", + "integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==", + "license": "MIT" + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve": { + "version": "1.22.2", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.2.tgz", + "integrity": "sha512-Sb+mjNHOULsBv818T40qSPeRiuWLyaGMa5ewydRLFimneixmVy2zdivRl+AF6jaYPC8ERxGDmFSiqui6SfPd+g==", + "license": "MIT", + "dependencies": { + "is-core-module": "^2.11.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/response-iterator": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/response-iterator/-/response-iterator-0.2.6.tgz", + "integrity": "sha512-pVzEEzrsg23Sh053rmDUvLSkGXluZio0qu8VT6ukrYuvtjVfCbDZH9d6PGXb8HZfzdNZt8feXv/jvUzlhRgLnw==", + "license": "MIT", + "engines": { + "node": ">=0.8" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "license": "ISC", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/ripemd160": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", + "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", + "license": "MIT", + "dependencies": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1" + } + }, + "node_modules/ripemd160-min": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/ripemd160-min/-/ripemd160-min-0.0.6.tgz", + "integrity": "sha512-+GcJgQivhs6S9qvLogusiTcS9kQUfgR75whKuy5jIhuiOfQuJ8fjqxV6EGD5duH1Y/FawFUMtMhyeq3Fbnib8A==", + "engines": { + "node": ">=8" + } + }, + "node_modules/rlp": { + "version": "2.2.7", + "resolved": "https://registry.npmjs.org/rlp/-/rlp-2.2.7.tgz", + "integrity": "sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ==", + "license": "MPL-2.0", + "dependencies": { + "bn.js": "^5.2.0" + }, + "bin": { + "rlp": "bin/rlp" + } + }, + "node_modules/rpc-websockets": { + "version": "7.5.1", + "resolved": "https://registry.npmjs.org/rpc-websockets/-/rpc-websockets-7.5.1.tgz", + "integrity": "sha512-kGFkeTsmd37pHPMaHIgN1LVKXMi0JD782v4Ds9ZKtLlwdTKjn+CxM9A9/gLT2LaOuEcEFGL98h1QWQtlOIdW0w==", + "license": "LGPL-3.0-only", + "dependencies": { + "@babel/runtime": "^7.17.2", + "eventemitter3": "^4.0.7", + "uuid": "^8.3.2", + "ws": "^8.5.0" + }, + "funding": { + "type": "paypal", + "url": "https://paypal.me/kozjak" + }, + "optionalDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + } + }, + "node_modules/rpc-websockets/node_modules/ws": { + "version": "8.13.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.13.0.tgz", + "integrity": "sha512-x9vcZYTrFPC7aSIbj7sRCYo7L/Xb8Iy+pW0ng0wt2vCJv7M9HOMy0UoN3rr+IFC7hb7vXoqS+P9ktyLLLhO+LA==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/rxjs": { + "version": "7.8.0", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.0.tgz", + "integrity": "sha512-F2+gxDshqmIub1KdvZkaEfGDwLNpPvk9Fs6LD/MyQxNgMds/WH9OdDDXOmxUZpME+iSK3rQCctkL0DYyytUqMg==", + "license": "Apache-2.0", + "dependencies": { + "tslib": "^2.1.0" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/scrypt-js": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/scrypt-js/-/scrypt-js-3.0.1.tgz", + "integrity": "sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==", + "license": "MIT" + }, + "node_modules/secp256k1": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-4.0.3.tgz", + "integrity": "sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "elliptic": "^6.5.4", + "node-addon-api": "^2.0.0", + "node-gyp-build": "^4.2.0" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/serialize-javascript": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz", + "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==", + "license": "BSD-3-Clause", + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "node_modules/setimmediate": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz", + "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==", + "license": "MIT" + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "license": "ISC" + }, + "node_modules/sha.js": { + "version": "2.4.11", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", + "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", + "license": "(MIT AND BSD-3-Clause)", + "dependencies": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + }, + "bin": { + "sha.js": "bin.js" + } + }, + "node_modules/sha3": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/sha3/-/sha3-2.1.4.tgz", + "integrity": "sha512-S8cNxbyb0UGUM2VhRD4Poe5N58gJnJsLJ5vC7FYWGUmGhcsj4++WaIOBFVDxlG0W3To6xBuiRh+i0Qp2oNCOtg==", + "license": "MIT", + "dependencies": { + "buffer": "6.0.3" + } + }, + "node_modules/shelljs": { + "version": "0.8.5", + "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.8.5.tgz", + "integrity": "sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==", + "license": "BSD-3-Clause", + "dependencies": { + "glob": "^7.0.0", + "interpret": "^1.0.0", + "rechoir": "^0.6.2" + }, + "bin": { + "shjs": "bin/shjs" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/shx": { + "version": "0.3.4", + "resolved": "https://registry.npmjs.org/shx/-/shx-0.3.4.tgz", + "integrity": "sha512-N6A9MLVqjxZYcVn8hLmtneQWIJtp8IKzMP4eMnx+nqkvXoqinUPCbUFLp2UcWTEIUONhlk0ewxr/jaVGlc+J+g==", + "license": "MIT", + "dependencies": { + "minimist": "^1.2.3", + "shelljs": "^0.8.5" + }, + "bin": { + "shx": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/snake-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/snake-case/-/snake-case-3.0.4.tgz", + "integrity": "sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==", + "license": "MIT", + "dependencies": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/snakecase-keys": { + "version": "5.4.5", + "resolved": "https://registry.npmjs.org/snakecase-keys/-/snakecase-keys-5.4.5.tgz", + "integrity": "sha512-qSQVcgcWk8mQUN1miVGnRMAUye1dbj9+F9PVkR7wZUXNCidQwrl/kOKmoYf+WbH2ju6c9pXnlmbS2he7pb2/9A==", + "license": "MIT", + "dependencies": { + "map-obj": "^4.1.0", + "snake-case": "^3.0.4", + "type-fest": "^2.5.2" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/statuses": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz", + "integrity": "sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/store2": { + "version": "2.14.2", + "resolved": "https://registry.npmjs.org/store2/-/store2-2.14.2.tgz", + "integrity": "sha512-siT1RiqlfQnGqgT/YzXVUNsom9S0H1OX+dpdGN1xkyYATo4I6sep5NmsRD/40s3IIOvlCq6akxkqG82urIZW1w==", + "license": "(MIT OR GPL-3.0)" + }, + "node_modules/string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/strip-hex-prefix": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-hex-prefix/-/strip-hex-prefix-1.0.0.tgz", + "integrity": "sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A==", + "license": "MIT", + "dependencies": { + "is-hex-prefixed": "1.0.0" + }, + "engines": { + "node": ">=6.5.0", + "npm": ">=3" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/superstruct": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/superstruct/-/superstruct-1.0.3.tgz", + "integrity": "sha512-8iTn3oSS8nRGn+C2pgXSKPI3jmpm6FExNazNpjvqS6ZUJQCej3PUXEKM8NjHBOs54ExM+LPW/FBRhymrdcCiSg==", + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/symbol-observable": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/symbol-observable/-/symbol-observable-4.0.0.tgz", + "integrity": "sha512-b19dMThMV4HVFynSAM1++gBHAbk2Tc/osgLIBZMKsyqh34jb2e8Os7T6ZW/Bt3pJFdBTd2JwAnAAEQV7rSNvcQ==", + "license": "MIT", + "engines": { + "node": ">=0.10" + } + }, + "node_modules/text-encoding-utf-8": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/text-encoding-utf-8/-/text-encoding-utf-8-1.0.2.tgz", + "integrity": "sha512-8bw4MY9WjdsD2aMtO0OzOCY3pXGYNx2d2FfHRVUKkiCPDWjKuOlhLVASS+pD7VkLTVjW268LYJHwsnPFlBpbAg==" + }, + "node_modules/through": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", + "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==", + "license": "MIT" + }, + "node_modules/through2": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz", + "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==", + "license": "MIT", + "dependencies": { + "readable-stream": "~2.3.6", + "xtend": "~4.0.1" + } + }, + "node_modules/through2/node_modules/isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==", + "license": "MIT" + }, + "node_modules/through2/node_modules/readable-stream": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz", + "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==", + "license": "MIT", + "dependencies": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "node_modules/through2/node_modules/safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "license": "MIT" + }, + "node_modules/through2/node_modules/string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.1.0" + } + }, + "node_modules/tiny-secp256k1": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/tiny-secp256k1/-/tiny-secp256k1-1.1.6.tgz", + "integrity": "sha512-FmqJZGduTyvsr2cF3375fqGHUovSwDi/QytexX1Se4BPuPZpTE5Ftp5fg+EFSuEf3lhZqgCRjEG3ydUQ/aNiwA==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "bindings": "^1.3.0", + "bn.js": "^4.11.8", + "create-hmac": "^1.1.7", + "elliptic": "^6.4.0", + "nan": "^2.13.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/tiny-secp256k1/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "license": "MIT" + }, + "node_modules/tmp": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.1.tgz", + "integrity": "sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==", + "license": "MIT", + "dependencies": { + "rimraf": "^3.0.0" + }, + "engines": { + "node": ">=8.17.0" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/toml": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/toml/-/toml-3.0.0.tgz", + "integrity": "sha512-y/mWCZinnvxjTKYhJ+pYxwD0mRLVvOtdS2Awbgxln6iEnt4rk0yBxeSBHkGJcPucRiG0e55mwWp+g/05rsrd6w==", + "license": "MIT" + }, + "node_modules/tr46": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", + "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==", + "license": "MIT" + }, + "node_modules/ts-invariant": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/ts-invariant/-/ts-invariant-0.10.3.tgz", + "integrity": "sha512-uivwYcQaxAucv1CzRp2n/QdYPo4ILf9VXgH19zEIjFx2EJufV16P0JtJVpYHy89DItG6Kwj2oIUjrcK5au+4tQ==", + "license": "MIT", + "dependencies": { + "tslib": "^2.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ts-mocha": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/ts-mocha/-/ts-mocha-10.0.0.tgz", + "integrity": "sha512-VRfgDO+iiuJFlNB18tzOfypJ21xn2xbuZyDvJvqpTbWgkAgD17ONGr8t+Tl8rcBtOBdjXp5e/Rk+d39f7XBHRw==", + "license": "MIT", + "dependencies": { + "ts-node": "7.0.1" + }, + "bin": { + "ts-mocha": "bin/ts-mocha" + }, + "engines": { + "node": ">= 6.X.X" + }, + "optionalDependencies": { + "tsconfig-paths": "^3.5.0" + }, + "peerDependencies": { + "mocha": "^3.X.X || ^4.X.X || ^5.X.X || ^6.X.X || ^7.X.X || ^8.X.X || ^9.X.X || ^10.X.X" + } + }, + "node_modules/ts-mocha/node_modules/diff": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz", + "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==", + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/ts-mocha/node_modules/ts-node": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-7.0.1.tgz", + "integrity": "sha512-BVwVbPJRspzNh2yfslyT1PSbl5uIk03EZlb493RKHN4qej/D06n1cEhjlOJG69oFsE7OT8XjpTUcYf6pKTLMhw==", + "dependencies": { + "arrify": "^1.0.0", + "buffer-from": "^1.1.0", + "diff": "^3.1.0", + "make-error": "^1.1.1", + "minimist": "^1.2.0", + "mkdirp": "^0.5.1", + "source-map-support": "^0.5.6", + "yn": "^2.0.0" + }, + "bin": { + "ts-node": "dist/bin.js" + }, + "engines": { + "node": ">=4.2.0" + } + }, + "node_modules/ts-mocha/node_modules/yn": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/yn/-/yn-2.0.0.tgz", + "integrity": "sha512-uTv8J/wiWTgUTg+9vLTi//leUl5vDQS6uii/emeTb2ssY7vl6QWf2fFbIIGjnhjvbdKlU0ed7QPgY1htTC86jQ==", + "engines": { + "node": ">=4" + } + }, + "node_modules/ts-node": { + "version": "10.9.1", + "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz", + "integrity": "sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==", + "dependencies": { + "@cspotcode/source-map-support": "^0.8.0", + "@tsconfig/node10": "^1.0.7", + "@tsconfig/node12": "^1.0.7", + "@tsconfig/node14": "^1.0.0", + "@tsconfig/node16": "^1.0.2", + "acorn": "^8.4.1", + "acorn-walk": "^8.1.1", + "arg": "^4.1.0", + "create-require": "^1.1.0", + "diff": "^4.0.1", + "make-error": "^1.1.1", + "v8-compile-cache-lib": "^3.0.1", + "yn": "3.1.1" + }, + "bin": { + "ts-node": "dist/bin.js", + "ts-node-cwd": "dist/bin-cwd.js", + "ts-node-esm": "dist/bin-esm.js", + "ts-node-script": "dist/bin-script.js", + "ts-node-transpile-only": "dist/bin-transpile.js", + "ts-script": "dist/bin-script-deprecated.js" + }, + "peerDependencies": { + "@swc/core": ">=1.2.50", + "@swc/wasm": ">=1.2.50", + "@types/node": "*", + "typescript": ">=2.7" + }, + "peerDependenciesMeta": { + "@swc/core": { + "optional": true + }, + "@swc/wasm": { + "optional": true + } + } + }, + "node_modules/ts-node/node_modules/acorn": { + "version": "8.8.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz", + "integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/ts-node/node_modules/diff": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz", + "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==", + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/tsconfig-paths": { + "version": "3.14.2", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.2.tgz", + "integrity": "sha512-o/9iXgCYc5L/JxCHPe3Hvh8Q/2xm5Z+p18PESBU6Ff33695QnCHBEjcytY2q19ua7Mbl/DavtBOLq+oG0RCL+g==", + "license": "MIT", + "optional": true, + "dependencies": { + "@types/json5": "^0.0.29", + "json5": "^1.0.2", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + } + }, + "node_modules/tslib": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.5.0.tgz", + "integrity": "sha512-336iVw3rtn2BUK7ORdIAHTyxHGRIHVReokCR3XjbckJMK7ms8FysBfhLR8IXnAgy7T0PTPNBWKiH514FOW/WSg==", + "license": "0BSD" + }, + "node_modules/tweetnacl": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz", + "integrity": "sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==", + "license": "Unlicense" + }, + "node_modules/tweetnacl-util": { + "version": "0.15.1", + "resolved": "https://registry.npmjs.org/tweetnacl-util/-/tweetnacl-util-0.15.1.tgz", + "integrity": "sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw==", + "license": "Unlicense" + }, + "node_modules/type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/type-fest": { + "version": "2.19.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-2.19.0.tgz", + "integrity": "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==", + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=12.20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typeforce": { + "version": "1.18.0", + "resolved": "https://registry.npmjs.org/typeforce/-/typeforce-1.18.0.tgz", + "integrity": "sha512-7uc1O8h1M1g0rArakJdf0uLRSSgFcYexrVoKo+bzJd32gd4gDy2L/Z+8/FjPnU9ydY3pEnVPtr9FyscYY60K1g==", + "license": "MIT" + }, + "node_modules/typescript": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.4.tgz", + "integrity": "sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==", + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=12.20" + } + }, + "node_modules/u3": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/u3/-/u3-0.1.1.tgz", + "integrity": "sha512-+J5D5ir763y+Am/QY6hXNRlwljIeRMZMGs0cT6qqZVVzzT3X3nFPXVyPOFRMOR4kupB0T8JnCdpWdp6Q/iXn3w==", + "license": "MIT" + }, + "node_modules/untildify": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/untildify/-/untildify-4.0.0.tgz", + "integrity": "sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/utf-8-validate": { + "version": "5.0.10", + "resolved": "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-5.0.10.tgz", + "integrity": "sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "node-gyp-build": "^4.3.0" + }, + "engines": { + "node": ">=6.14.2" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "license": "MIT" + }, + "node_modules/uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "license": "MIT", + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/v8-compile-cache-lib": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz", + "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==" + }, + "node_modules/vlq": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/vlq/-/vlq-2.0.4.tgz", + "integrity": "sha512-aodjPa2wPQFkra1G8CzJBTHXhgk3EVSwxSWXNPr1fgdFLUb8kvLV1iEb6rFgasIsjP82HWI6dsb5Io26DDnasA==", + "license": "MIT" + }, + "node_modules/webidl-conversions": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", + "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==", + "license": "BSD-2-Clause" + }, + "node_modules/whatwg-url": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", + "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", + "license": "MIT", + "dependencies": { + "tr46": "~0.0.3", + "webidl-conversions": "^3.0.0" + } + }, + "node_modules/wif": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/wif/-/wif-2.0.6.tgz", + "integrity": "sha512-HIanZn1zmduSF+BQhkE+YXIbEiH0xPr1012QbFEGB0xsKqJii0/SqJjyn8dFv6y36kOznMgMB+LGcbZTJ1xACQ==", + "license": "MIT", + "dependencies": { + "bs58check": "<3.0.0" + } + }, + "node_modules/workerpool": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz", + "integrity": "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==", + "license": "Apache-2.0" + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "license": "ISC" + }, + "node_modules/ws": { + "version": "7.5.9", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz", + "integrity": "sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==", + "license": "MIT", + "engines": { + "node": ">=8.3.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/xstream": { + "version": "11.14.0", + "resolved": "https://registry.npmjs.org/xstream/-/xstream-11.14.0.tgz", + "integrity": "sha512-1bLb+kKKtKPbgTK6i/BaoAn03g47PpFstlbe1BA+y3pNS/LfvcaghS5BFf9+EE1J+KwSQsEpfJvFN5GqFtiNmw==", + "license": "MIT", + "dependencies": { + "globalthis": "^1.0.1", + "symbol-observable": "^2.0.3" + } + }, + "node_modules/xstream/node_modules/symbol-observable": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/symbol-observable/-/symbol-observable-2.0.3.tgz", + "integrity": "sha512-sQV7phh2WCYAn81oAkakC5qjq2Ml0g8ozqz03wOGnx9dDlG1de6yrF+0RAzSJD8fPUow3PTSMf2SAbOGxb93BA==", + "license": "MIT", + "engines": { + "node": ">=0.10" + } + }, + "node_modules/xtend": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", + "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", + "license": "MIT", + "engines": { + "node": ">=0.4" + } + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs": { + "version": "16.2.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", + "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", + "license": "MIT", + "dependencies": { + "cliui": "^7.0.2", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.0", + "y18n": "^5.0.5", + "yargs-parser": "^20.2.2" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-parser": { + "version": "20.2.4", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz", + "integrity": "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-unparser": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz", + "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==", + "license": "MIT", + "dependencies": { + "camelcase": "^6.0.0", + "decamelize": "^4.0.0", + "flat": "^5.0.2", + "is-plain-obj": "^2.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-unparser/node_modules/camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/yargs/node_modules/yargs-parser": { + "version": "20.2.9", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz", + "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yn": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz", + "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==", + "engines": { + "node": ">=6" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zen-observable": { + "version": "0.8.15", + "resolved": "https://registry.npmjs.org/zen-observable/-/zen-observable-0.8.15.tgz", + "integrity": "sha512-PQ2PC7R9rslx84ndNBZB/Dkv8V8fZEpk83RLgXtYd0fwUgEjseMn1Dgajh2x6S8QbZAFa9p2qVCEuYZNgve0dQ==", + "license": "MIT" + }, + "node_modules/zen-observable-ts": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/zen-observable-ts/-/zen-observable-ts-1.2.5.tgz", + "integrity": "sha512-QZWQekv6iB72Naeake9hS1KxHlotfRpe+WGNbNx5/ta+R3DNjVO2bswf63gXlWDcs+EMd7XY8HfVQyP1X6T4Zg==", + "license": "MIT", + "dependencies": { + "zen-observable": "0.8.15" + } + } + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/package.json b/target_chains/iota/vendor/wormhole_iota_testnet/testing/package.json new file mode 100644 index 0000000000..f29c59e15c --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/package.json @@ -0,0 +1,22 @@ +{ + "name": "@wormhole-foundation/wormhole-sui-integration-test", + "version": "0.0.1", + "description": "Wormhole Sui Integration Test", + "main": "index.js", + "license": "MIT", + "dependencies": { + "@certusone/wormhole-sdk": "^0.9.12", + "@mysten/sui.js": "^0.32.2", + "chai": "^4.3.7", + "mocha": "^10.2.0", + "prettier": "^2.8.7", + "ts-mocha": "^10.0.0", + "ts-node": "^10.9.1", + "typescript": "^5.0.4" + }, + "devDependencies": { + "@types/chai": "^4.3.4", + "@types/mocha": "^10.0.1", + "@types/node": "^18.15.11" + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/run_integration_test.sh b/target_chains/iota/vendor/wormhole_iota_testnet/testing/run_integration_test.sh new file mode 100755 index 0000000000..80da863836 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/run_integration_test.sh @@ -0,0 +1,35 @@ +#/bin/bash + +pgrep -f sui > /dev/null +if [ $? -eq 0 ]; then + echo "sui local validator already running" + exit 1; +fi + +TEST_DIR=$(dirname $0) +SUI_CONFIG=$TEST_DIR/sui_config + +### Remove databases generated by localnet +rm -rf $SUI_CONFIG/*_db + +### Start local node +echo "$(date) :: starting localnet" +sui start --network.config $SUI_CONFIG/network.yaml > /dev/null 2>&1 & +sleep 1 + +echo "$(date) :: deploying wormhole and token bridge" +cd $TEST_DIR/.. +bash scripts/deploy.sh devnet \ + -k AGA20wtGcwbcNAG4nwapbQ5wIuXwkYQEWFUoSVAxctHb > deploy.out 2>&1 +cd testing + +## run contract tests here +echo "$(date) :: running tests" +pnpm exec ts-mocha -t 1000000 $TEST_DIR/js/*.ts + +# nuke +echo "$(date) :: done" +pkill sui + +# remove databases generated by localnet +rm -rf $SUI_CONFIG/*_db diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/scripts/upgrade-token-bridge.ts b/target_chains/iota/vendor/wormhole_iota_testnet/testing/scripts/upgrade-token-bridge.ts new file mode 100644 index 0000000000..605128dddb --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/scripts/upgrade-token-bridge.ts @@ -0,0 +1,300 @@ +import * as mock from "@certusone/wormhole-sdk/lib/cjs/mock"; +import { + RawSigner, + SUI_CLOCK_OBJECT_ID, + TransactionBlock, + fromB64, + normalizeSuiObjectId, + JsonRpcProvider, + Ed25519Keypair, + testnetConnection, +} from "@mysten/sui.js"; +import { execSync } from "child_process"; +import { resolve } from "path"; +import * as fs from "fs"; + +const GOVERNANCE_EMITTER = + "0000000000000000000000000000000000000000000000000000000000000004"; + +const TOKEN_BRIDGE_STATE_ID = + "0x32422cb2f929b6a4e3f81b4791ea11ac2af896b310f3d9442aa1fe924ce0bab4"; +const WORMHOLE_STATE_ID = + "0x69ae41bdef4770895eb4e7aaefee5e4673acc08f6917b4856cf55549c4573ca8"; + +async function main() { + const guardianPrivateKey = process.env.TESTNET_GUARDIAN_PRIVATE_KEY; + if (guardianPrivateKey === undefined) { + throw new Error("TESTNET_GUARDIAN_PRIVATE_KEY unset in environment"); + } + + const walletPrivateKey = process.env.TESTNET_WALLET_PRIVATE_KEY; + if (walletPrivateKey === undefined) { + throw new Error("TESTNET_WALLET_PRIVATE_KEY unset in environment"); + } + + const provider = new JsonRpcProvider(testnetConnection); + const wallet = new RawSigner( + Ed25519Keypair.fromSecretKey( + Buffer.from(walletPrivateKey, "base64").subarray(1) + ), + provider + ); + + const dstTokenBridgePath = resolve(`${__dirname}/../../token_bridge`); + + // Build for digest. + const { modules, dependencies, digest } = + buildForBytecodeAndDigest(dstTokenBridgePath); + console.log("dependencies", dependencies); + console.log("digest", digest.toString("hex")); + + // We will use the signed VAA when we execute the upgrade. + const guardians = new mock.MockGuardians(0, [guardianPrivateKey]); + + const timestamp = 12345678; + const governance = new mock.GovernanceEmitter(GOVERNANCE_EMITTER); + const published = governance.publishWormholeUpgradeContract( + timestamp, + 2, + "0x" + digest.toString("hex") + ); + const moduleName = Buffer.alloc(32); + moduleName.write("TokenBridge", 32 - "TokenBridge".length); + published.write(moduleName.toString(), 84 - 33); + published.writeUInt16BE(21, 84); + published.writeUInt8(2, 83); + //message.writeUInt8(1, 83); + published.writeUInt16BE(21, published.length - 34); + + const signedVaa = guardians.addSignatures(published, [0]); + console.log("Upgrade VAA:", signedVaa.toString("hex")); + + // // And execute upgrade with governance VAA. + // const upgradeResults = await upgradeTokenBridge( + // wallet, + // TOKEN_BRIDGE_STATE_ID, + // WORMHOLE_STATE_ID, + // modules, + // dependencies, + // signedVaa + // ); + + // console.log("tx digest", upgradeResults.digest); + // console.log("tx effects", JSON.stringify(upgradeResults.effects!)); + // console.log("tx events", JSON.stringify(upgradeResults.events!)); + + // TODO: grab new package ID from the events above. Do not rely on the RPC + // call because it may give you a stale package ID after the upgrade. + + const migrateResults = await migrateTokenBridge( + wallet, + TOKEN_BRIDGE_STATE_ID, + WORMHOLE_STATE_ID, + signedVaa + ); + console.log("tx digest", migrateResults.digest); + console.log("tx effects", JSON.stringify(migrateResults.effects!)); + console.log("tx events", JSON.stringify(migrateResults.events!)); +} + +main(); + +// Yeah buddy. + +function buildForBytecodeAndDigest(packagePath: string) { + const buildOutput: { + modules: string[]; + dependencies: string[]; + digest: number[]; + } = JSON.parse( + execSync( + `sui move build --dump-bytecode-as-base64 -p ${packagePath} 2> /dev/null`, + { encoding: "utf-8" } + ) + ); + return { + modules: buildOutput.modules.map((m: string) => Array.from(fromB64(m))), + dependencies: buildOutput.dependencies.map((d: string) => + normalizeSuiObjectId(d) + ), + digest: Buffer.from(buildOutput.digest), + }; +} + +async function getPackageId( + provider: JsonRpcProvider, + stateId: string +): Promise { + const state = await provider + .getObject({ + id: stateId, + options: { + showContent: true, + }, + }) + .then((result) => { + if (result.data?.content?.dataType == "moveObject") { + return result.data.content.fields; + } + + throw new Error("not move object"); + }); + + if ("upgrade_cap" in state) { + return state.upgrade_cap.fields.package; + } + + throw new Error("upgrade_cap not found"); +} + +async function upgradeTokenBridge( + signer: RawSigner, + tokenBridgeStateId: string, + wormholeStateId: string, + modules: number[][], + dependencies: string[], + signedVaa: Buffer +) { + const tokenBridgePackage = await getPackageId( + signer.provider, + tokenBridgeStateId + ); + const wormholePackage = await getPackageId(signer.provider, wormholeStateId); + + const tx = new TransactionBlock(); + + const [verifiedVaa] = tx.moveCall({ + target: `${wormholePackage}::vaa::parse_and_verify`, + arguments: [ + tx.object(wormholeStateId), + tx.pure(Array.from(signedVaa)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + const [decreeTicket] = tx.moveCall({ + target: `${tokenBridgePackage}::upgrade_contract::authorize_governance`, + arguments: [tx.object(tokenBridgeStateId)], + }); + const [decreeReceipt] = tx.moveCall({ + target: `${wormholePackage}::governance_message::verify_vaa`, + arguments: [tx.object(wormholeStateId), verifiedVaa, decreeTicket], + typeArguments: [ + `${tokenBridgePackage}::upgrade_contract::GovernanceWitness`, + ], + }); + + // Authorize upgrade. + const [upgradeTicket] = tx.moveCall({ + target: `${tokenBridgePackage}::upgrade_contract::authorize_upgrade`, + arguments: [tx.object(tokenBridgeStateId), decreeReceipt], + }); + + // Build and generate modules and dependencies for upgrade. + const [upgradeReceipt] = tx.upgrade({ + modules, + dependencies, + packageId: tokenBridgePackage, + ticket: upgradeTicket, + }); + + // Commit upgrade. + tx.moveCall({ + target: `${tokenBridgePackage}::upgrade_contract::commit_upgrade`, + arguments: [tx.object(tokenBridgeStateId), upgradeReceipt], + }); + + // Cannot auto compute gas budget, so we need to configure it manually. + // Gas ~215m. + //tx.setGasBudget(1_000_000_000n); + + return signer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} + +async function migrateTokenBridge( + signer: RawSigner, + tokenBridgeStateId: string, + wormholeStateId: string, + signedUpgradeVaa: Buffer +) { + const tokenBridgePackage = await getPackageId( + signer.provider, + tokenBridgeStateId + ); + const wormholePackage = await getPackageId(signer.provider, wormholeStateId); + + const tx = new TransactionBlock(); + + const [verifiedVaa] = tx.moveCall({ + target: `${wormholePackage}::vaa::parse_and_verify`, + arguments: [ + tx.object(wormholeStateId), + tx.pure(Array.from(signedUpgradeVaa)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + const [decreeTicket] = tx.moveCall({ + target: `${tokenBridgePackage}::upgrade_contract::authorize_governance`, + arguments: [tx.object(tokenBridgeStateId)], + }); + const [decreeReceipt] = tx.moveCall({ + target: `${wormholePackage}::governance_message::verify_vaa`, + arguments: [tx.object(wormholeStateId), verifiedVaa, decreeTicket], + typeArguments: [ + `${tokenBridgePackage}::upgrade_contract::GovernanceWitness`, + ], + }); + tx.moveCall({ + target: `${tokenBridgePackage}::migrate::migrate`, + arguments: [tx.object(tokenBridgeStateId), decreeReceipt], + }); + + return signer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} + +function setUpWormholeDirectory( + srcWormholePath: string, + dstWormholePath: string +) { + fs.cpSync(srcWormholePath, dstWormholePath, { recursive: true }); + + // Remove irrelevant files. This part is not necessary, but is helpful + // for debugging a clean package directory. + const removeThese = [ + "Move.devnet.toml", + "Move.lock", + "Makefile", + "README.md", + "build", + ]; + for (const basename of removeThese) { + fs.rmSync(`${dstWormholePath}/${basename}`, { + recursive: true, + force: true, + }); + } + + // Fix Move.toml file. + const moveTomlPath = `${dstWormholePath}/Move.toml`; + const moveToml = fs.readFileSync(moveTomlPath, "utf-8"); + fs.writeFileSync( + moveTomlPath, + moveToml.replace(`wormhole = "_"`, `wormhole = "0x0"`), + "utf-8" + ); +} + +function cleanUpPackageDirectory(packagePath: string) { + fs.rmSync(packagePath, { recursive: true, force: true }); +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/scripts/upgrade-wormhole.ts b/target_chains/iota/vendor/wormhole_iota_testnet/testing/scripts/upgrade-wormhole.ts new file mode 100644 index 0000000000..82d26b0f72 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/scripts/upgrade-wormhole.ts @@ -0,0 +1,267 @@ +import * as mock from "@certusone/wormhole-sdk/lib/cjs/mock"; +import { + RawSigner, + SUI_CLOCK_OBJECT_ID, + TransactionBlock, + fromB64, + normalizeSuiObjectId, + JsonRpcProvider, + Ed25519Keypair, + testnetConnection, +} from "@mysten/sui.js"; +import { execSync } from "child_process"; +import { resolve } from "path"; +import * as fs from "fs"; + +const GOVERNANCE_EMITTER = + "0000000000000000000000000000000000000000000000000000000000000004"; + +const WORMHOLE_STATE_ID = + "0x69ae41bdef4770895eb4e7aaefee5e4673acc08f6917b4856cf55549c4573ca8"; + +async function main() { + const guardianPrivateKey = process.env.TESTNET_GUARDIAN_PRIVATE_KEY; + if (guardianPrivateKey === undefined) { + throw new Error("TESTNET_GUARDIAN_PRIVATE_KEY unset in environment"); + } + + const walletPrivateKey = process.env.TESTNET_WALLET_PRIVATE_KEY; + if (walletPrivateKey === undefined) { + throw new Error("TESTNET_WALLET_PRIVATE_KEY unset in environment"); + } + + const provider = new JsonRpcProvider(testnetConnection); + const wallet = new RawSigner( + Ed25519Keypair.fromSecretKey( + Buffer.from(walletPrivateKey, "base64").subarray(1) + ), + provider + ); + + const srcWormholePath = resolve(`${__dirname}/../../wormhole`); + const dstWormholePath = resolve(`${__dirname}/wormhole`); + + // Stage build(s). + setUpWormholeDirectory(srcWormholePath, dstWormholePath); + + // Build for digest. + const { modules, dependencies, digest } = + buildForBytecodeAndDigest(dstWormholePath); + + // We will use the signed VAA when we execute the upgrade. + const guardians = new mock.MockGuardians(0, [guardianPrivateKey]); + + const timestamp = 12345678; + const governance = new mock.GovernanceEmitter(GOVERNANCE_EMITTER); + const published = governance.publishWormholeUpgradeContract( + timestamp, + 2, + "0x" + digest.toString("hex") + ); + published.writeUInt16BE(21, published.length - 34); + + const signedVaa = guardians.addSignatures(published, [0]); + console.log("Upgrade VAA:", signedVaa.toString("hex")); + + // And execute upgrade with governance VAA. + const upgradeResults = await buildAndUpgradeWormhole( + wallet, + WORMHOLE_STATE_ID, + modules, + dependencies, + signedVaa + ); + + console.log("tx digest", upgradeResults.digest); + console.log("tx effects", JSON.stringify(upgradeResults.effects!)); + console.log("tx events", JSON.stringify(upgradeResults.events!)); + + // TODO: grab new package ID from the events above. Do not rely on the RPC + // call because it may give you a stale package ID after the upgrade. + + // const migrateResults = await migrateWormhole( + // wallet, + // WORMHOLE_STATE_ID, + // signedVaa + // ); + // console.log("tx digest", migrateResults.digest); + // console.log("tx effects", JSON.stringify(migrateResults.effects!)); + // console.log("tx events", JSON.stringify(migrateResults.events!)); + + // Clean up. + cleanUpPackageDirectory(dstWormholePath); +} + +main(); + +// Yeah buddy. + +function buildForBytecodeAndDigest(packagePath: string) { + const buildOutput: { + modules: string[]; + dependencies: string[]; + digest: number[]; + } = JSON.parse( + execSync( + `sui move build --dump-bytecode-as-base64 -p ${packagePath} 2> /dev/null`, + { encoding: "utf-8" } + ) + ); + return { + modules: buildOutput.modules.map((m: string) => Array.from(fromB64(m))), + dependencies: buildOutput.dependencies.map((d: string) => + normalizeSuiObjectId(d) + ), + digest: Buffer.from(buildOutput.digest), + }; +} + +async function getPackageId( + provider: JsonRpcProvider, + stateId: string +): Promise { + const state = await provider + .getObject({ + id: stateId, + options: { + showContent: true, + }, + }) + .then((result) => { + if (result.data?.content?.dataType == "moveObject") { + return result.data.content.fields; + } + + throw new Error("not move object"); + }); + + if ("upgrade_cap" in state) { + return state.upgrade_cap.fields.package; + } + + throw new Error("upgrade_cap not found"); +} + +async function buildAndUpgradeWormhole( + signer: RawSigner, + wormholeStateId: string, + modules: number[][], + dependencies: string[], + signedVaa: Buffer +) { + const wormholePackage = await getPackageId(signer.provider, wormholeStateId); + + const tx = new TransactionBlock(); + + const [verifiedVaa] = tx.moveCall({ + target: `${wormholePackage}::vaa::parse_and_verify`, + arguments: [ + tx.object(wormholeStateId), + tx.pure(Array.from(signedVaa)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + const [decreeTicket] = tx.moveCall({ + target: `${wormholePackage}::upgrade_contract::authorize_governance`, + arguments: [tx.object(wormholeStateId)], + }); + const [decreeReceipt] = tx.moveCall({ + target: `${wormholePackage}::governance_message::verify_vaa`, + arguments: [tx.object(wormholeStateId), verifiedVaa, decreeTicket], + typeArguments: [`${wormholePackage}::upgrade_contract::GovernanceWitness`], + }); + + // Authorize upgrade. + const [upgradeTicket] = tx.moveCall({ + target: `${wormholePackage}::upgrade_contract::authorize_upgrade`, + arguments: [tx.object(wormholeStateId), decreeReceipt], + }); + + // Build and generate modules and dependencies for upgrade. + const [upgradeReceipt] = tx.upgrade({ + modules, + dependencies, + packageId: wormholePackage, + ticket: upgradeTicket, + }); + + // Commit upgrade. + tx.moveCall({ + target: `${wormholePackage}::upgrade_contract::commit_upgrade`, + arguments: [tx.object(wormholeStateId), upgradeReceipt], + }); + + // Cannot auto compute gas budget, so we need to configure it manually. + // Gas ~215m. + //tx.setGasBudget(1_000_000_000n); + + return signer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} + +async function migrateWormhole( + signer: RawSigner, + wormholeStateId: string, + signedUpgradeVaa: Buffer +) { + const contractPackage = await getPackageId(signer.provider, wormholeStateId); + + const tx = new TransactionBlock(); + tx.moveCall({ + target: `${contractPackage}::migrate::migrate`, + arguments: [ + tx.object(wormholeStateId), + tx.pure(Array.from(signedUpgradeVaa)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + return signer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} + +function setUpWormholeDirectory( + srcWormholePath: string, + dstWormholePath: string +) { + fs.cpSync(srcWormholePath, dstWormholePath, { recursive: true }); + + // Remove irrelevant files. This part is not necessary, but is helpful + // for debugging a clean package directory. + const removeThese = [ + "Move.devnet.toml", + "Move.lock", + "Makefile", + "README.md", + "build", + ]; + for (const basename of removeThese) { + fs.rmSync(`${dstWormholePath}/${basename}`, { + recursive: true, + force: true, + }); + } + + // Fix Move.toml file. + const moveTomlPath = `${dstWormholePath}/Move.toml`; + const moveToml = fs.readFileSync(moveTomlPath, "utf-8"); + fs.writeFileSync( + moveTomlPath, + moveToml.replace(`wormhole = "_"`, `wormhole = "0x0"`), + "utf-8" + ); +} + +function cleanUpPackageDirectory(packagePath: string) { + fs.rmSync(packagePath, { recursive: true, force: true }); +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/client.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/client.yaml new file mode 100644 index 0000000000..33371df956 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/client.yaml @@ -0,0 +1,12 @@ +--- +keystore: + File: sui_config/sui.keystore +envs: + - alias: localnet + rpc: "http://0.0.0.0:9000" + ws: ~ + - alias: devnet + rpc: "https://fullnode.devnet.sui.io:443" + ws: ~ +active_env: localnet +active_address: "0xed867315e3f7c83ae82e6d5858b6a6cc57c291fd84f7509646ebc8162169cf96" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/fullnode.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/fullnode.yaml new file mode 100644 index 0000000000..fc71e910e6 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/fullnode.yaml @@ -0,0 +1,53 @@ +--- +protocol-key-pair: + value: W+hPTVWhdFgzHs3YuRHV6gLfgFhHA1WG0pisIXiN8E8= +worker-key-pair: + value: AApEvpZE1O+2GMqZ1AbRE3+Kmgr1O5mdsMZ6I/gLpVSy +account-key-pair: + value: AN7ZHgjN8G7Nw7Q8NtY9TisPBjmEYpdUzbczjqR98XLh +network-key-pair: + value: AAnB6/zZooq4xDtB7oM/GeTSCh5tBxKAyJwWOMPlEJ4R +db-path: sui_config/authorities_db/full_node_db +network-address: /ip4/127.0.0.1/tcp/36683/http +json-rpc-address: "0.0.0.0:9000" +metrics-address: "127.0.0.1:35915" +admin-interface-port: 44319 +enable-event-processing: true +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: ~ +p2p-config: + listen-address: "127.0.0.1:38187" + external-address: /ip4/127.0.0.1/udp/38187 + seed-peers: + - peer-id: ce60e3077e02a3683436af450f3a4511b4c40b158956637caf9ccf11391e7e10 + address: /ip4/127.0.0.1/udp/44061 + - peer-id: 5f0f42cb3fb20dd577703388320964f9351d997313c04a032247060d214b2e71 + address: /ip4/127.0.0.1/udp/46335 + - peer-id: 6d9095130b1536c0c9218ea9feb0f36685a6fa0b3b1e67d256cc4fb340a48d69 + address: /ip4/127.0.0.1/udp/32965 + - peer-id: b2915bf787845a55c24e18fdc162a575eb02d23bae3f9e566d7c51ebcfeb4a42 + address: /ip4/127.0.0.1/udp/39889 +genesis: + genesis-file-location: sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/genesis.blob b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/genesis.blob new file mode 100644 index 0000000000..0bf9f806bc Binary files /dev/null and b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/genesis.blob differ diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/network.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/network.yaml new file mode 100644 index 0000000000..37122d68f0 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/network.yaml @@ -0,0 +1,324 @@ +--- +validator_configs: + - protocol-key-pair: + value: VTDx4HjVmRBqdqBWg2zN+zcFE20io3CrBchGy/iV1lo= + worker-key-pair: + value: ABlC9PMmIQHjxila3AEOXDxwCSuodcvJh2Q5O5HIB00K + account-key-pair: + value: AIV4Ng6OYQf6irjVCZly5X7dSpdFpwoWtdAx9u4PANRl + network-key-pair: + value: AOqJl2rHMnroe26vjkkIuWGBD/y6HzQG6MK5bC9njF0s + db-path: sui_config/authorities_db/99f25ef61f80 + network-address: /ip4/127.0.0.1/tcp/36459/http + json-rpc-address: "127.0.0.1:38133" + metrics-address: "127.0.0.1:44135" + admin-interface-port: 33917 + consensus-config: + address: /ip4/127.0.0.1/tcp/41459/http + db-path: sui_config/consensus_db/99f25ef61f80 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/44689/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/33219/http + network_admin_server: + primary_network_admin_server_port: 33945 + worker_network_admin_server_base_port: 38081 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:44061" + external-address: /ip4/127.0.0.1/udp/44061 + genesis: + genesis-file-location: sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false + - protocol-key-pair: + value: avYcyVgYMXTyaUYh9IRwLK0gSzl7YF6ZQDAbrS1Bhvo= + worker-key-pair: + value: AGsxCVxeIZ6fscvGECzV93Hi4JkqM4zMYEA8wBGfXQrz + account-key-pair: + value: AF9cOMxTRAUTOws2M8W5slHf41HITA+M3nqXHT6nlH6S + network-key-pair: + value: ALH/8qz2YlwAuxY/hOvuXiglYq0e4LLU1/lyf5uKgPY8 + db-path: sui_config/authorities_db/8dcff6d15504 + network-address: /ip4/127.0.0.1/tcp/33355/http + json-rpc-address: "127.0.0.1:39573" + metrics-address: "127.0.0.1:45851" + admin-interface-port: 35739 + consensus-config: + address: /ip4/127.0.0.1/tcp/42959/http + db-path: sui_config/consensus_db/8dcff6d15504 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/37001/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/39831/http + network_admin_server: + primary_network_admin_server_port: 39853 + worker_network_admin_server_base_port: 36429 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:46335" + external-address: /ip4/127.0.0.1/udp/46335 + genesis: + genesis-file-location: sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false + - protocol-key-pair: + value: OXnx3yM1C/ppgnDMx/o1d49fJs7E05kq11mXNae/O+I= + worker-key-pair: + value: AHXs8DP7EccyxtxAGq/m33LgvOApXs4JStH3PLAe9vGw + account-key-pair: + value: AC8vF9E3QYf0aTyBZWlSzJJXETvV5vYkOtEJl+DWQMlk + network-key-pair: + value: AOapcKU6mW5SopFM6eBSiXgbuPJTz11CiEqM+SJGIEOF + db-path: sui_config/authorities_db/addeef94d898 + network-address: /ip4/127.0.0.1/tcp/34633/http + json-rpc-address: "127.0.0.1:38025" + metrics-address: "127.0.0.1:43451" + admin-interface-port: 36793 + consensus-config: + address: /ip4/127.0.0.1/tcp/40307/http + db-path: sui_config/consensus_db/addeef94d898 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/37445/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/43943/http + network_admin_server: + primary_network_admin_server_port: 39611 + worker_network_admin_server_base_port: 38377 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:32965" + external-address: /ip4/127.0.0.1/udp/32965 + genesis: + genesis-file-location: sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false + - protocol-key-pair: + value: CyNkjqNVr3HrHTH7f/NLs7u5lUHJzuPAw0PqMTD2y2s= + worker-key-pair: + value: AHd6qvbBv7bTCGGoD1TUR5dOGnwOnYvhHV9ryCUp7rmZ + account-key-pair: + value: ALSCvWwsVryGIwq+n4f9bIPCRqsooGodE/vDaVCSLfjE + network-key-pair: + value: APFCK1pRVxn9PDt+KzWx52+EY5nzaZZU2GF9RZoQY58Y + db-path: sui_config/authorities_db/b3fd5efb5c87 + network-address: /ip4/127.0.0.1/tcp/33953/http + json-rpc-address: "127.0.0.1:35625" + metrics-address: "127.0.0.1:37813" + admin-interface-port: 46405 + consensus-config: + address: /ip4/127.0.0.1/tcp/43213/http + db-path: sui_config/consensus_db/b3fd5efb5c87 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/46745/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/38817/http + network_admin_server: + primary_network_admin_server_port: 34929 + worker_network_admin_server_base_port: 37447 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:39889" + external-address: /ip4/127.0.0.1/udp/39889 + genesis: + genesis-file-location: sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false +account_keys: [] +genesis: AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAINRCoP2A/TVqNfPAfndpv33WFbqdGt8UUaAP28Xiv8m4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyjYfxIcBAAAAAAAAAAAAAAAAAIsN7KKhcSvE07253vGyxVXEMi5V5Pm7Yp6ooavX4pSFYCIBTuWN2hv40J8J0sdQMxg6MAAAAQAAAAAAAwAQAAAAAAABAAIAAwAAASA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyCBz3ecai2p3AnFvhrBoUGQrtgb/zLrK42Tw56HwaBu5VQEAAQAAAAACMQABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAAAsDYmNzXKEc6wsGAAAABgEAAgMCBgUIBwcPDQgcIAw8BAAAAAEAAQEAAQYJAAEKAgNiY3MIdG9fYnl0ZXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQABAgAABGhhc2hqoRzrCwYAAAAGAQACAwIKBQwDBw8XCCYgDEYIAAAAAQAAAAACAAAAAQoCBGhhc2gIc2hhMl8yNTYIc2hhM18yNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQABAgABAQIAAAVhc2NpaZcGoRzrCwYAAAALAQAEAgQOAxJUBGYIBW47B6kByAEI8QIgBpEDCgqbAwsMpgO6Ag3gBQQABQAQAAIHAAAABwABAQcBAAAACAABAAAUAgMAABUCBAAAAwUGAAASBwgAABEJAQAADgUKAAAEBQsAAAoDAgAABgEAAAANAAYAAAsABgABCQ0OAQABDAwGAQABDwgNAQABEw4NAQANAwwDDgMPAwECAQgBAQoCAQgAAQsCAQgAAQYIAAEBAgcIAAgBAAEHCAABAwEGCgIBBgsCAQkAAQsCAQkAAQkAAgMDBENoYXIGT3B0aW9uBlN0cmluZxhhbGxfY2hhcmFjdGVyc19wcmludGFibGUIYXNfYnl0ZXMFYXNjaWkEYnl0ZQVieXRlcwRjaGFyDGRlc3Ryb3lfc29tZQppbnRvX2J5dGVzEWlzX3ByaW50YWJsZV9jaGFyB2lzX3NvbWUNaXNfdmFsaWRfY2hhcgZsZW5ndGgEbm9uZQZvcHRpb24IcG9wX2NoYXIJcHVzaF9jaGFyBHNvbWUGc3RyaW5nCnRyeV9zdHJpbmcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAABAAAAAAAAAgEHCgIBAgEGAgABAAAICQoAEQoEBAUGBwAnCwASAQIBAQAABAwLABECDAEOATgABAcFCQcAJwsBOAECAgEAAA8eDgBBAAwCBgAAAAAAAAAADAEoCgEKAiMEGQULDgAKAUIAFBEKIAQUOAICCwEGAQAAAAAAAAAWDAEFBSgLABIAOAMCAwEAAA8gCgAQAEEADAIGAAAAAAAAAAAMASgKAQoCIwQdBQwKABAACgFCABQRCyAEGAsAAQkCCwEGAQAAAAAAAAAWDAEFBigIAgQBAAAIBwsADwAOARABFEQAAgUBAAAIBQsADwBFABIBAgYBAAAIBAsAEQdBAAIHAQAACAMLABAAAggBAAAIAwsAEwACCQEAAAgDCwATAQIKAQAACAQLADF/JQILAQAABg0KADEgJgQJCwAxfiUMAQULCQwBCwECAAABAAAFZGVidWd0oRzrCwYAAAAGAQACAwILBQ0FBxIeCDAgDFAIAAAAAQABAQAAAgEBAAEGCQAABWRlYnVnBXByaW50EXByaW50X3N0YWNrX3RyYWNlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQIAAQECAAAGb3B0aW9u8QihHOsLBgAAAA0BAAQCBAYDCngEggEOBZABhwEHlwLbAQjyAyAGkgQUCqYEBwutBAIMrwSABA2vCAIOsQgCAA8AFgAABwEAAAAOAAEBAAARAgEBAAAMAwQBAAANAwQBAAAEBQQBAAABAwYBAAADBQYBAAAKBwIBAwAJCAABAAAICQIBAAACCQoBAAASCAIBAAATCAEBAAAHCwIBAgAGAQIBAAAFAQABAAAUAQwBAAEEDgQBAAELDQQBAAEQAgwBABMCEgIRAgMCAAIBAgICAAELAAEJAAEJAAEGCwABCQABAQIGCwABCQAGCQABBgkAAgYLAAEJAAkAAgcLAAEJAAkAAQcLAAEJAAEHCQACCwABCQAJAAEKCQABBgoJAAIGCgkABgkAAgYJAAYKCQACCQAGCgkAAQcKCQACCQAHCgkAAwsAAQkACwABCQAHCgkAAgkACgkABk9wdGlvbgZib3Jyb3cKYm9ycm93X211dBNib3Jyb3dfd2l0aF9kZWZhdWx0CGNvbnRhaW5zDGRlc3Ryb3lfbm9uZQxkZXN0cm95X3NvbWUUZGVzdHJveV93aXRoX2RlZmF1bHQHZXh0cmFjdARmaWxsEGdldF93aXRoX2RlZmF1bHQIaXNfZW1wdHkHaXNfbm9uZQdpc19zb21lBG5vbmUGb3B0aW9uCXNpbmdsZXRvbgRzb21lBHN3YXAMc3dhcF9vcl9maWxsBnRvX3ZlYwN2ZWMGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAABAAAAAAAAwgBAAQAAAAAAAACARUKCQAAAgABAAAAA0ACAAAAAAAAAAA5AAIBAQAAAAQLADgAOQACAgEAAAAECwA3ADgBAgMBAAAABQsANwA4ASACBAEAAAAFCwA3AAsBOAICBQEAAAANCgA4AwQEBQgLAAEHAScLADcABgAAAAAAAAAAQgICBgEAAA8TCwA3AAwDCgM4AQQLCwMBCwEMAgURCwEBCwMGAAAAAAAAAABCAgwCCwICBwEAABASCwA3AAwDCgM4AQQLCwMBCwEMAgUQCwMGAAAAAAAAAABCAhQMAgsCAggBAAAREAsANgAMAgoCLjgBBAgFDAsCAQcAJwsCCwFEAgIJAQAAAA0KAC44AwQFBQkLAAEHAScLADYARQICCgEAAAAOCgAuOAMEBQUJCwABBwEnCwA2AAYAAAAAAAAAAEMCAgsBAAASFAoALjgDBAUFCQsAAQcBJwsANgAMAwoDRQIMAgsDCwFEAgsCAgwBAAATFQsANgAMBAoELjgBBAo4BAwCBQ4KBEUCOAUMAgsCDAMLBAsBRAILAwINAQAAFA8LADoADAMNAy44AQQKCwEMAgUNDQNFAgwCCwICDgEAABQQDgA4AwQEBQYHAScLADoADAINAkUCDAELAkYCAAAAAAAAAAALAQIPAQAAAAoOADgGBAQFBgcAJwsAOgBGAgAAAAAAAAAAAhABAAAAAwsAOgACAAAAAgAGc3RyaW5n+QehHOsLBgAAAAsBAAgCCA4DFnIEiAEIBZABeweLAvgBCIMEIAajBBQKtwQGDL0EhQMNwgcCABMABAARABgAAQcAAQEHAAIABwEAAAAXAAEAAAYCAQAAFQECAAAWAAMAAAUEBQAADgQGAAAPBAcAAAIICQAAAwoJAAAICwkAABQMAQAABw0HAAAJBQYAAAsOBgAADA8AAAAKEAcAAQ0CAAABEwACAAIQCRIBAAISERIBAAMCFQkBAAMOFAYBABMBEgEVExQTAQoCAQgAAQgBAQsCAQgAAQYIAAEGCgIBAQEDAgcIAAgAAAIHCAAKAgMHCAADCAADBggAAwMCBggABggAAgYKAgMDBgoCAwMCBgoCBgoCAQkAAQsCAQkAAQIBBgoJAAIHCgkACgkACAEDAwMGCgIIAAgAAwUBAQEGCgIDBk9wdGlvbgZTdHJpbmcGYXBwZW5kC2FwcGVuZF91dGY4BWFzY2lpBWJ5dGVzCmZyb21fYXNjaWkIaW5kZXhfb2YGaW5zZXJ0E2ludGVybmFsX2NoZWNrX3V0ZjgRaW50ZXJuYWxfaW5kZXhfb2YZaW50ZXJuYWxfaXNfY2hhcl9ib3VuZGFyeRNpbnRlcm5hbF9zdWJfc3RyaW5nCmludG9fYnl0ZXMIaXNfZW1wdHkGbGVuZ3RoBG5vbmUGb3B0aW9uBHNvbWUGc3RyaW5nCnN1Yl9zdHJpbmcIdG9fYXNjaWkIdHJ5X3V0ZjgEdXRmOAZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAQAAAAAAAAADCAIAAAAAAAAAAAIBBQoCAAEAAAkJDgARDAQEBQYHACcLABIAAgEBAAAJBAsAERASAAICAQAACQQLABMAERECAwEAAAMMDgARDAQICwASADgADAEFCjgBDAELAQIEAQAACQMLABAAAgUBAAAJBAsAEAA4AgIGAQAACQQLABAAQRMCBwEAAAkHCwAPAA4BEAAUOAMCCAEAAAkFCwALAREAEQcCCQEAABY4CgAQAAwHCgEKB0ETJQQNCwcKARENDAMFEQsHAQkMAwsDBBQFGAsAAQcBJwoALhEGDAoKAAoBDAQuBgAAAAAAAAAACwQRCgwJCgALAQsKDAYMBS4LBQsGEQoMCA0JCwIRBw0JCwgRBwsJCwAVAgoBAAAXMAsAEAAMBgoGQRMMBwoCCwclBA8KAQoCJQwDBREJDAMLAwQYCgYKARENDAQFGgkMBAsEBCEKBgoCEQ0MBQUjCQwFCwUEJgUqCwYBBwEnCwYLAQsCEQ4SAAILAQAACQYLABAACwEQABEPAgwAAgANAAIADgACAA8AAgAAAAAGdmVjdG9ykQihHOsLBgAAAAgBAAIDAmYEaAQFbGEHzQGaAQjnAiAGhwMKDJED2AQAEQAFAAEBAAAJAgMBAAABBAUBAAALBgABAAACBwgBAAAKCQoBAAAEAQABAAAPCwABAAAOCgEBAAANCQABAAAADAABAAAIAg0BAAADDg0BAAAGDg8BAAAMBwoBAAAHEAABAAAQBwoBAAkKCwoAAQoJAAEGCgkAAQMCBgoJAAMBBgkAAgcKCQAJAAIHCgkAAwEHCQABBwoJAAEJAAMHCgkAAwMCBwoJAAoJAAEBAgYKCQAGCQACAQMDBwoJAAkAAwMDAwMCAwMDAwcKCQADBmFwcGVuZAZib3Jyb3cKYm9ycm93X211dAhjb250YWlucw1kZXN0cm95X2VtcHR5BWVtcHR5CGluZGV4X29mBmluc2VydAhpc19lbXB0eQZsZW5ndGgIcG9wX2JhY2sJcHVzaF9iYWNrBnJlbW92ZQdyZXZlcnNlCXNpbmdsZXRvbgRzd2FwC3N3YXBfcmVtb3ZlBnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAIAAAAAAAABAgABAQIAAgECAAMBAgAEAQIABQECAAYBAgAHAQIACAEAAAEHQAoAAAAAAAAAAAwBDQELAEQKCwECCQEAABEmCgAuQQoMAwoDBgAAAAAAAAAAIQQLCwABAgYAAAAAAAAAAAwCCwMGAQAAAAAAAAAXDAEKAgoBIwQjBRYKAAoCCgFHCgsCBgEAAAAAAAAAFgwCCwEGAQAAAAAAAAAXDAEFEQsAAQIKAQAAABENATgADgE4ASAEDAUHCgANAUUKRAoFAgsAAQsBRgoAAAAAAAAAAAILAQAAAAULAEEKBgAAAAAAAAAAIQIMAQAAEiEGAAAAAAAAAAAMAgoAQQoMAwoCCgMjBBsFCgoACgJCCgoBIQQWCwABCwEBCAILAgYBAAAAAAAAABYMAgUFCwABCwEBCQINAQAAEiMGAAAAAAAAAAAMAgoAQQoMAwoCCgMjBBwFCgoACgJCCgoBIQQXCwABCwEBCAsCAgsCBgEAAAAAAAAAFgwCBQULAAELAQEJBgAAAAAAAAAAAg4BAAATJQoALkEKDAQKAQoEJgQMCwABBwAnCwQGAQAAAAAAAAAXDAQKAQoEIwQiBRUKAAwDCgEMAgsBBgEAAAAAAAAAFgwBCwMLAgoBRwoFEAsARQoCDwEAAAMgCgAuQQoMAwoCCgMkBAwLAAEHACcKAAsBRAoKAgoDIwQdBRQKAAoCCgNHCgsCBgEAAAAAAAAAFgwCBQ8LAAECEAEAAAMXCgAuOAEgBAYFCgsAAQcAJwoALkEKBgEAAAAAAAAAFwwCCgALAQsCRwoLAEUKAgAHYWRkcmVzc2WhHOsLBgAAAAYBAAIDAgUFBwMHCg8IGSAMORAAAAABAAEAAAEDB2FkZHJlc3MGbGVuZ3RoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQAAAAIGIAAAAAAAAAACAAl0eXBlX25hbWWMBKEc6wsGAAAACgEABgIGCAMOKQU3LAdjeQjcASAG/AEHCoMCBgyJAtMBDdwDAgANAAIABAABBwACAAcAAAYAAQEAAAUCAwAABwIEAAAIAgQAAAkBBAABCgAGAAIDAwcAAgwJBAAAAQgAAQYIAAEGCAEBCAEECgIDAwYKAgEDAQYKAgECAQoCBQIGAgMKAgYKAgZTdHJpbmcIVHlwZU5hbWUHYWRkcmVzcwhhc19ieXRlcwVhc2NpaQ1ib3Jyb3dfc3RyaW5nA2dldAtnZXRfYWRkcmVzcwpnZXRfbW9kdWxlC2ludG9fc3RyaW5nBmxlbmd0aARuYW1lBnN0cmluZwl0eXBlX25hbWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIBOgoCAQAAAgELCAEAAQIAAQEAAAADCwAQAAICAQAABSERBQYCAAAAAAAAABgMAwsAEAARBgwEBwEMAQYAAAAAAAAAAAwCCgIKAyMEHAURDQEKBAoCQggURAgLAgYBAAAAAAAAABYMAgUMCwQBCwERBwIDAQAACicRBQYCAAAAAAAAABgGAgAAAAAAAAAWDAMLABAAEQYMBQcBDAQKBQoDQggMAgcADAEKAg4BIgQgBRcNBAsCFEQICwMGAQAAAAAAAAAWDAMFDAsFAQsCAQsEEQcCBAEAAAAEDgAQABQCAAAACmJpdF92ZWN0b3KrBqEc6wsGAAAACgEAAgICBAMGIwUpJAdNbQi6ASAG2gEoCoICCAyKAu8DDfkFBAACAAAHAAAGAAEAAAcCAwAACQIDAAAIAgMAAAMEBQAABAYAAAAFBAAAAQMBCAACBwgAAwACBggAAwEBAQYIAAIKAQMBBwEFAwcBAwMDCUJpdFZlY3RvcgliaXRfZmllbGQKYml0X3ZlY3Rvcgxpc19pbmRleF9zZXQGbGVuZ3RoIGxvbmdlc3Rfc2V0X3NlcXVlbmNlX3N0YXJ0aW5nX2F0A25ldwNzZXQKc2hpZnRfbGVmdAV1bnNldAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAIAAAAAAAMIAQACAAAAAAADCAEAAAAAAAAAAwgABAAAAAAAAAACAgQDAQoBAAEAAAclCgAGAAAAAAAAAAAkBAUFBwcBJwoABwMjBAwFDgcBJwYAAAAAAAAAAAwCQAUAAAAAAAAAAAwBKAoCCgAjBCAFGA0BCUQFCwIGAQAAAAAAAAAWDAIFEigLAAsBEgACAQEAAAgUCgEKABAAQQUjBAcFCwsAAQcAJwsADwALAUMFDAIICwIVAgIBAAAIFAoBCgAQAEEFIwQHBQsLAAEHACcLAA8ACwFDBQwCCQsCFQIDAQAACVkKAQoAEAEUJgQhCgAQAEEFDAYGAAAAAAAAAAAMBAoECgYjBB4FEQoADwAKBEMFDAMJCwMVCwQGAQAAAAAAAAAWDAQFDAsAAQVYCgEMBQoFCgAQARQjBEEFKgoACgUMAi4LAhEEBDcKAAoFCgEXEQEFPAoACgUKARcRAgsFBgEAAAAAAAAAFgwFBSMKABABFAsBFwwFCgUKABABFCMEVgVOCgAKBRECCwUGAQAAAAAAAAAWDAUFRwsAAQIEAQAAAxEKAQoAEABBBSMEBwULCwABBwAnCwAQAAsBQgUUAgUBAAADBAsAEABBBQIGAQAAACUKAQoAEAEUIwQHBQsLAAEHACcKAQwCCgIKABABFCMEIQUUCgAKAhEEIAQcCwABBSELAgYBAAAAAAAAABYMAgUNCwILARcCAAEAAAANZml4ZWRfcG9pbnQzMtYEoRzrCwYAAAAKAQACAgIEAwYeBSQWBzp6CLQBIAbUAUQKmAIFDJ0CiQINpgQCAAQAAAcAAAcAAQAAAwABAAABAgMAAAIBAwAABQMBAAAGAwQAAgMIAAEDAgMDAQgAAQEBBAQBBAQEAAxGaXhlZFBvaW50MzIUY3JlYXRlX2Zyb21fcmF0aW9uYWwVY3JlYXRlX2Zyb21fcmF3X3ZhbHVlCmRpdmlkZV91NjQNZml4ZWRfcG9pbnQzMg1nZXRfcmF3X3ZhbHVlB2lzX3plcm8MbXVsdGlwbHlfdTY0BXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEEP//////////AAAAAAAAAAADCAEAAQAAAAAAAwgCAAIAAAAAAAMIAwACAAAAAAADCAQAAQAAAAAAAwgFAAIAAAAAAAACAQgDAAEAAAUUCwA1DgEQABQ1GDEgMAwCCgIHACUEDwURBwMnCwI0AgEBAAAFHQ4BEAAUBgAAAAAAAAAAIgQHBQkHBCcLADUxIC8OARAAFDUaDAIKAgcAJQQYBRoHAicLAjQCAgEAAAYwCgA1MUAvDAULATUxIC8MBAoEMgAAAAAAAAAAAAAAAAAAAAAiBA8FEQcBJwsFCwQaDAMKAzIAAAAAAAAAAAAAAAAAAAAAIgQcCAwCBSALAAYAAAAAAAAAACEMAgsCBCMFJQcFJwoDBwAlBCoFLAcFJwsDNBIAAgMBAAAHAwsAEgACBAEAAAcEDgAQABQCBQEAAAcGDgAQABQGAAAAAAAAAAAhAgAAAAcNZml4ZWRfcG9pbnQzMgxGaXhlZFBvaW50MzIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQZvcHRpb24GT3B0aW9uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEFYXNjaWkGU3RyaW5nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEFYXNjaWkEQ2hhcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCmJpdF92ZWN0b3IJQml0VmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEGc3RyaW5nBlN0cmluZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCXR5cGVfbmFtZQhUeXBlTmFtZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAMAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQAAAAAAAAApA2JhZ+wFoRzrCwYAAAALAQAIAggMAxRwBIQBDAWQAVIH4gG5AQibAyAGuwMKCsUDCAzNA+YBDbMFBAAEAAsAEgAVAAAMAAICBAADAQIAABEAAQAAAwIDAgcEAAUEBQIHBAAGBgcCBwQAEwYIAgcEAAcECQEHAAgECQIHBAAQCgsAAA8KCQAACgEDAAEDDgMCBwQBBQ8FAgcEAQYQBwIHBAEMDwkBBwENDwkCBwQBExAIAgcEAgkMAwACEQAMAAoNCw0MDQ8NDREODQEHCAIBCAADBwgACQAJAQACBggACQABBgkBAgcIAAkAAQcJAQEJAQEBAQYIAAEDAQgBAgkACQEDBwgBCQAJAQIGCAEJAAIHCAEJAAEJAAIIAQMDQmFnCVR4Q29udGV4dANVSUQDYWRkA2JhZwZib3Jyb3cKYm9ycm93X211dAhjb250YWlucxJjb250YWluc193aXRoX3R5cGUGZGVsZXRlDWRlc3Ryb3lfZW1wdHkNZHluYW1pY19maWVsZAdleGlzdHNfEGV4aXN0c193aXRoX3R5cGUCaWQIaXNfZW1wdHkGbGVuZ3RoA25ldwZvYmplY3QGcmVtb3ZlBHNpemUKdHhfY29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAACAg4IARQDAAEAAAMFCwAREQYAAAAAAAAAABIAAgEBAAADDgoADwALAQsCOAAKABABFAYBAAAAAAAAABYLAA8BFQICAQAAAwULABAACwE4AQIDAQAAAwULAA8ACwE4AgIEAQAACA8KAA8ACwE4AwwCCgAQARQGAQAAAAAAAAAXCwAPARULAgIFAQAAAwULABAACwE4BAIGAQAAAwULABAACwE4BQIHAQAAAwQLABABFAIIAQAAAwYLABABFAYAAAAAAAAAACECCQEAABIOCwATAAwCDAELAgYAAAAAAAAAACEECQULBwAnCwEREAIAAAABAANiY3OVD6Ec6wsGAAAACwEACgIKCgMUhwEEmwEYBbMBgwEHtgLeAgiUBUAG1AU3CosGBgyRBssIDdwOAgADAQMBCgEfAAIAAAcAAgEHAQAAAB4AAQEAAAgBAgAABgIBAAALAwQAAAwDBQAAFAMGAAATAwcAABIDCAAAFwMHAAAVAwkAABYDCgAAGgMBAAAbAwsAABkDDAAAGAMNAAANAw4AAA4DDwAAEQMQAAAQAxEAAA8DEgABHgABAQACCRMhAQACHRQhAQADHBUTAQAEBQEEAAQHEwcAFBQXBhYEFQQWBRUFFgYVBhYHFQcWCBUIAQYJAAEKAgEIAAEHCAABBQEBAQIBAwEEAQoFAQoBAQoKAgEKAwEKBAELAQEFAQsBAQEBCwEBAgELAQEDAQsBAQQAAQkAAQcKCQACCgIDAgECAwMCAwMEAgQEAwMCAwMDAwoFAwMDCgEDAwMKAgMDAwoKAgMDAwoDAwMDCgQBCwEBCQADQkNTBk9wdGlvbgdhZGRyZXNzA2JjcwVieXRlcwpmcm9tX2J5dGVzFGludG9fcmVtYWluZGVyX2J5dGVzBmxlbmd0aANuZXcEbm9uZQZvcHRpb24McGVlbF9hZGRyZXNzCXBlZWxfYm9vbBNwZWVsX29wdGlvbl9hZGRyZXNzEHBlZWxfb3B0aW9uX2Jvb2wQcGVlbF9vcHRpb25fdTEyOA9wZWVsX29wdGlvbl91NjQOcGVlbF9vcHRpb25fdTgJcGVlbF91MTI4CHBlZWxfdTY0B3BlZWxfdTgQcGVlbF92ZWNfYWRkcmVzcw1wZWVsX3ZlY19ib29sD3BlZWxfdmVjX2xlbmd0aA1wZWVsX3ZlY191MTI4DHBlZWxfdmVjX3U2NAtwZWVsX3ZlY191OA9wZWVsX3ZlY192ZWNfdTgHcmV2ZXJzZQRzb21lCHRvX2J5dGVzBnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAAKBQEACgEBAAoCAQAKCgIBAAoDAQAKBAEAAAIBBAoCAAEAABMDCwA4AAIBAQAAEwUNADgBCwASAAICAQAAAQcLABMADAENATgBCwECAwEAABYjCgAQAEEGERkmBAcFCwsAAQcAJ0AGAAAAAAAAAAAGAAAAAAAAAAAMAgwBCgIRGSMEHgUUDQEKAA8ARQZEBgsCBgEAAAAAAAAAFgwCBQ8LAAELAREYAgQBAAAXFQsAEQUMAgoCMQAhBAoJDAEFEwsCMQEhBA8FEQcBJwgMAQsBAgUBAAATDwoAEABBBgYBAAAAAAAAACYEBwULCwABBwAnCwAPAEUGAgYBAAAYKAoAEABBBgYIAAAAAAAAACYEBwULCwABBwAnBgAAAAAAAAAAMQAMAgwDCgIxQCMEJAUUCgAPAEUGNAwBCwMLAQoCLxYMAwsCMQgWDAIFDwsAAQsDAgcBAAAZKAoAEABBBgYQAAAAAAAAACYEBwULCwABBwAnMgAAAAAAAAAAAAAAAAAAAAAxAAwCDAMKAjGAIwQkBRQKAA8ARQY1DAELAwsBCgIvFgwDCwIxCBYMAgUPCwABCwMCCAEAABowBgAAAAAAAAAAMQAGAAAAAAAAAAAMAgwDDAQKAgYEAAAAAAAAACUECwUPCwABBwInCgAPAEUGNAwBCwIGAQAAAAAAAAAWDAILBAoBBn8AAAAAAAAAHAoDLxsMBAsBBoAAAAAAAAAAHAYAAAAAAAAAACEEJwUsCwMxBxYMAwUGCwABCwQCCQEAABsZCgARCAYAAAAAAAAAAAcDDAMMAQwCCgEKAiMEFQUMDQMKABEDRAQLAQYBAAAAAAAAABYMAQUHCwABCwMCCgEAABwZCgARCAYAAAAAAAAAAAcEDAMMAQwCCgEKAiMEFQUMDQMKABEERAULAQYBAAAAAAAAABYMAQUHCwABCwMCCwEAAB0ZCgARCAYAAAAAAAAAAAcFDAMMAQwCCgEKAiMEFQUMDQMKABEFRAYLAQYBAAAAAAAAABYMAQUHCwABCwMCDAEAAB4ZCgARCAYAAAAAAAAAAAcGDAMMAQwCCgEKAiMEFQUMDQMKABELRAELAQYBAAAAAAAAABYMAQUHCwABCwMCDQEAAB8ZCgARCAYAAAAAAAAAAAcHDAMMAQwCCgEKAiMEFQUMDQMKABEGRAcLAQYBAAAAAAAAABYMAQUHCwABCwMCDgEAACAZCgARCAYAAAAAAAAAAAcIDAMMAQwCCgEKAiMEFQUMDQMKABEHRAgLAQYBAAAAAAAAABYMAQUHCwABCwMCDwEAAA4OCgARBAQICwARAzgCDAEFDAsAATgDDAELAQIQAQAADw4KABEEBAgLABEEOAQMAQUMCwABOAUMAQsBAhEBAAAQDgoAEQQECAsAEQU4BgwBBQwLAAE4BwwBCwECEgEAABEOCgARBAQICwARBjgIDAEFDAsAATgJDAELAQITAQAAEg4KABEEBAgLABEHOAoMAQUMCwABOAsMAQsBAgAAAANoZXizCqEc6wsGAAAACAEABAMEFQQZAgUbJQdALAhsQAasAZ8GDMsHwgIABAEFAAMAAAAAAQAAAAACAQEAAQADBAEAAwEBCgIBAgUKCgIHCgIDAwoCAgcKCQAKCQAABAIDAwoCBQEBAQICBmFwcGVuZAZkZWNvZGULZGVjb2RlX2J5dGUGZW5jb2RlA2hleAZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAAKCgKCBoACAjAwAjAxAjAyAjAzAjA0AjA1AjA2AjA3AjA4AjA5AjBhAjBiAjBjAjBkAjBlAjBmAjEwAjExAjEyAjEzAjE0AjE1AjE2AjE3AjE4AjE5AjFhAjFiAjFjAjFkAjFlAjFmAjIwAjIxAjIyAjIzAjI0AjI1AjI2AjI3AjI4AjI5AjJhAjJiAjJjAjJkAjJlAjJmAjMwAjMxAjMyAjMzAjM0AjM1AjM2AjM3AjM4AjM5AjNhAjNiAjNjAjNkAjNlAjNmAjQwAjQxAjQyAjQzAjQ0AjQ1AjQ2AjQ3AjQ4AjQ5AjRhAjRiAjRjAjRkAjRlAjRmAjUwAjUxAjUyAjUzAjU0AjU1AjU2AjU3AjU4AjU5AjVhAjViAjVjAjVkAjVlAjVmAjYwAjYxAjYyAjYzAjY0AjY1AjY2AjY3AjY4AjY5AjZhAjZiAjZjAjZkAjZlAjZmAjcwAjcxAjcyAjczAjc0Ajc1Ajc2Ajc3Ajc4Ajc5AjdhAjdiAjdjAjdkAjdlAjdmAjgwAjgxAjgyAjgzAjg0Ajg1Ajg2Ajg3Ajg4Ajg5AjhhAjhiAjhjAjhkAjhlAjhmAjkwAjkxAjkyAjkzAjk0Ajk1Ajk2Ajk3Ajk4Ajk5AjlhAjliAjljAjlkAjllAjlmAmEwAmExAmEyAmEzAmE0AmE1AmE2AmE3AmE4AmE5AmFhAmFiAmFjAmFkAmFlAmFmAmIwAmIxAmIyAmIzAmI0AmI1AmI2AmI3AmI4AmI5AmJhAmJiAmJjAmJkAmJlAmJmAmMwAmMxAmMyAmMzAmM0AmM1AmM2AmM3AmM4AmM5AmNhAmNiAmNjAmNkAmNlAmNmAmQwAmQxAmQyAmQzAmQ0AmQ1AmQ2AmQ3AmQ4AmQ5AmRhAmRiAmRjAmRkAmRlAmRmAmUwAmUxAmUyAmUzAmU0AmU1AmU2AmU3AmU4AmU5AmVhAmViAmVjAmVkAmVlAmVmAmYwAmYxAmYyAmYzAmY0AmY1AmY2AmY3AmY4AmY5AmZhAmZiAmZjAmZkAmZlAmZmCgIBAAABAAACIQYAAAAAAAAAAAcDDgBBAQwEDAUMAwoDCgQjBB8FDA0FDAIHAgwBCwIOAQ4ACgNCARQ0QgAUOAALAwYBAAAAAAAAABYMAwUHCwUCAQEAAAUvBgAAAAAAAAAABwMOAEEBDAMMBAwCCgMGAgAAAAAAAAAZBgAAAAAAAAAAIQQOBRAHACcKAgoDIwQtBRUOAAoCQgEUEQIxEBgOAAoCBgEAAAAAAAAAFkIBFBECFgwBDQQLAUQBCwIGAgAAAAAAAAAWDAIFEAsEAgIAAAAGQDEwCgAlBAkKADE6IwwBBQsJDAELAQQSCwAxMBcMBQU+MUEKACUEGwoAMUcjDAIFHQkMAgsCBCYxCgsAFjFBFwwEBTwxYQoAJQQvCgAxZyMMAwUxCQwDCwMENAU2BwEnMQoLABYxYRcMBAsEDAULBQIAA3BhecMGoRzrCwYAAAAJAQAIAggKAxJNBF8OBW1+B+sBrQEImAMgBrgDCgzCA9YCAAkAAgAPABABAAwBAAEDAQIAAAgAAQEAAAwCAQEAAA4DAQEAAA0EAQEAAAMCAQEAAAUFAQEAAAYGAQEAAAcHAQEAAQQCEAEAAQUFAQEAAQwCCgEAAgoLAQEMAwsICQALCgoMAAwBDAgMCQwGDAILAAEJAAYIAQADBwsAAQkAAwcIAQMHCwABCQAKAwcIAQQHCwABCQADBQcIAQIHCwABCQALAAEJAAIHCwABCQAKCwABCQACCgsAAQkABQEGCAEBBQELAAEJAAIJAAUBCQACAwMBAwMDAwoLAAEJAAEKCwABCQADCwABCQADAwRDb2luCVR4Q29udGV4dARjb2luD2RpdmlkZV9hbmRfa2VlcA1kaXZpZGVfaW50b19uBGpvaW4Iam9pbl92ZWMVam9pbl92ZWNfYW5kX3RyYW5zZmVyBGtlZXADcGF5D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIFc3BsaXQSc3BsaXRfYW5kX3RyYW5zZmVyCXNwbGl0X3ZlYwh0cmFuc2Zlcgp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAAEAAAEFCwALAREMOAACAQEEAAEICwALAQoCOAELAi44AgICAQQADRsGAAAAAAAAAAAOAUEODAQMAwoDCgQjBBYFCgoADgEKA0IOFAoCOAMLAwYBAAAAAAAAABYMAwUFCwABCwIBAgMBBAABBwsACwELAzgBCwI4AAIEAQQADx8LAAsBCgI4BAwFBgAAAAAAAAAADgVBCgwEDAMKAwoEIwQaBQ8NBUUKCgIuEQw4AAsDBgEAAAAAAAAAFgwDBQoLAgELBUYKAAAAAAAAAAACBQEEAAEECwALATgFAgYBBAARGgYAAAAAAAAAAA4BQQoMBAwDCgMKBCMEFQUKDQFFCgwCCgALAjgFCwMGAQAAAAAAAAAWDAMFBQsAAQsBRgoAAAAAAAAAAAIHAQQAChIOAEEKBgAAAAAAAAAAJAQGBQgHACcNAEUKDAINAgsAOAYLAgsBOAACAANzdWnYBqEc6wsGAAAACgEADgIOMAM+PgR8DgWKAYUBB48CgQIIkARABtAEZgq2BQUMuwVtABYBEgAJAAoAFwAZABoABAIAAQMHAQAAAgAEAQABAgUEAQABAwEMAQABAwIMAQABAwYMAQABBQcCAAYIBwAAEAABAAAXAgMAAREDCQEAAgwQBwEAAg8REgEAAwsLDAECAxgPEAEABBMOAwEMBBQUAwEMBQ4FBwAFFQUGAAIIBQoHDQYKBAoDCggTAQcIBwELAgEIAAILBAEIAAUABAsFAQgACwMBCAALAgEIAAsGAQgAAQYIBwEFAQMBCAgBCwEBCQABCAAHCQACCgIKAgoCCwEBCAgHCAcCCwYBCQALBQEJAAELBQEIAAEJAAELBgEJAAELAwEJAAIHCwMBCQADAQsCAQkAAQsEAQgAAgkABQdCYWxhbmNlBENvaW4MQ29pbk1ldGFkYXRhBk9wdGlvbgNTVUkGU3VwcGx5C1RyZWFzdXJ5Q2FwCVR4Q29udGV4dANVcmwHYmFsYW5jZQRjb2luD2NyZWF0ZV9jdXJyZW5jeQ5kZXN0cm95X3N1cHBseQtkdW1teV9maWVsZAVlcG9jaA9pbmNyZWFzZV9zdXBwbHkDbmV3BG5vbmUGb3B0aW9uFHB1YmxpY19mcmVlemVfb2JqZWN0D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIDc3VpCHRyYW5zZmVyFHRyZWFzdXJ5X2ludG9fc3VwcGx5CnR4X2NvbnRleHQDdXJsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgAypo7AAAAAAMIAOQLVAIAAAADCAAA6IkEI8eKBSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCBANTVUkKAgQDU3VpCgIBAAACAQ0BAAAAAAQvCgAuEQoHBSEEBwULCwABBwEnCgAuEQkGAAAAAAAAAAAhBBIFFgsAAQcAJwkSADEJBwYHBwcIOAALADgBDAEMBAsBOAILBDgDDAINAgcEOAQMAwsCOAUBCwMCAQEEAAMECwALATgGAgADdXJsqgKhHOsLBgAAAAkBAAQCBAgDDBkFJRQHOU4IhwFACscBBgzNATIN/wECAAgBAgABBwABAAcAAAQAAQAABQIBAAADAwAAAAcEBQABBgIAAAEIAQEIAAEKAgEGCAACBwgACAEABlN0cmluZwNVcmwFYXNjaWkJaW5uZXJfdXJsCm5ld191bnNhZmUVbmV3X3Vuc2FmZV9mcm9tX2J5dGVzBnN0cmluZwZ1cGRhdGUDdXJsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQACAQgIAQABAAAFAwsAEgACAQEAAAUECwARBBIAAgIBAAAFBAsAEAAUAgMBAAAFBQsBCwAPABUCAAAABGNvaW6BEqEc6wsGAAAADQEAFgIWPgNUmwIE7wIkBZMD4wIH9gWiBQiYC0AG2AseCvYLNAuqDAgMsgz0BA2mEQ4OtBEOAA8BCwEtATIADAAZACwAOQA7ADwAQQABDAEAAQACDAEAAQAHDAEAAQADAwEAAQEFBwACBAcBAAADBQcABAAEAQABBAYEAQABBgkEAAgIAgAKCgcAADgAAQEAADoCAwEAADMEBQEAADQEBgEAAEMHAQEAAAwHCAEAAA0JCgEAABoLDAEAACMMDQEAADcODAEAAC8PEAEAACUREAEAADESDAEAABcSEwEAAEQUDAEAABYMEAEAABAVFgECACYXDAEAACgYDQEAAA4ZAQEAACcaEAEAAD8bEAEAAEAcEAEAAD0bEAEAAD4cEAEAABsdHgEAAB4dHwEAAB8dIAEAABwdHwEAAB0dIQEAATIqIAACMCIvAQADQiofAAQRIgMBAgQTLAEBAAQWDRABAAQiKw0BAAQlJQEBAAQxJA0BAAQ1BQEBAARDCAEBAAREEA0BAAUYIhABAwYUIxAABioUIwAHLi0QAQwJJCcoAQIKKyAuACciKCImIggiJSIJIgQiDCIpIiMiLiIqKSEiJCIiIhEiLQwfLgEGCwIBCQABAwELAgEJAAELCAEJAAEHCwIBCQABBgsIAQkAAQcLCAEJAAEGCwABCQABBgsHAQkAAQcLAAEJAAEHCwcBCQACCwcBCQAHCAoBCwABCQABCwcBCQADBwsHAQkAAwcICgIHCwcBCQALAAEJAAACBwsAAQkACwABCQADBwsAAQkAAwcICgEKCwABCQABBwgKBwkAAgoCCgIKAgsFAQgLBwgKAgsCAQkACwEBCQADBwsCAQkAAwcICgIHCwIBCQADAgcLAgEJAAsAAQkABAcLAgEJAAMFBwgKAwYLAgEJAAcLAQEJAAgGAwYLAgEJAAcLAQEJAAgEAQYLAQEJAAECAQgGAQgEAQsFAQgLAQkAAQgJAgcLBwEJAAMCBwsHAQkACwcBCQADAwMKCwABCQABBgkAAQEBCwMBCQABCgICBwsIAQkAAwIHCwgBCQALBwEJAAIJAAUBCAsBCwUBCQAHQmFsYW5jZQRDb2luDENvaW5NZXRhZGF0YQ9DdXJyZW5jeUNyZWF0ZWQGT3B0aW9uBlN0cmluZwZTdXBwbHkLVHJlYXN1cnlDYXAJVHhDb250ZXh0A1VJRANVcmwFYXNjaWkHYmFsYW5jZQtiYWxhbmNlX211dARidXJuBGNvaW4PY3JlYXRlX2N1cnJlbmN5DWNyZWF0ZV9zdXBwbHkIZGVjaW1hbHMPZGVjcmVhc2Vfc3VwcGx5BmRlbGV0ZQtkZXNjcmlwdGlvbgxkZXN0cm95X3plcm8NZGl2aWRlX2ludG9fbgRlbWl0BWV2ZW50DGZyb21fYmFsYW5jZQxnZXRfZGVjaW1hbHMPZ2V0X2Rlc2NyaXB0aW9uDGdldF9pY29uX3VybAhnZXRfbmFtZQpnZXRfc3ltYm9sCGljb25fdXJsAmlkD2luY3JlYXNlX3N1cHBseQxpbnRvX2JhbGFuY2UTaXNfb25lX3RpbWVfd2l0bmVzcwRqb2luBG1pbnQRbWludF9hbmRfdHJhbnNmZXIMbWludF9iYWxhbmNlBG5hbWUDbmV3Cm5ld191bnNhZmUGb2JqZWN0Bm9wdGlvbg9wdWJsaWNfdHJhbnNmZXIDcHV0BHNvbWUFc3BsaXQGc3RyaW5nBnN1cHBseQpzdXBwbHlfbXV0DHN1cHBseV92YWx1ZQZzeW1ib2wEdGFrZQx0b3RhbF9zdXBwbHkIdHJhbnNmZXIUdHJlYXN1cnlfaW50b19zdXBwbHkKdHhfY29udGV4dAV0eXBlcxJ1cGRhdGVfZGVzY3JpcHRpb24PdXBkYXRlX2ljb25fdXJsC3VwZGF0ZV9uYW1lDXVwZGF0ZV9zeW1ib2wDdXJsBHV0ZjgFdmFsdWUEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAAAAgIhCAkMCwcBCQABAgYhCAkSAikIBjYIBBUIBiALBQEICwICAiEICTgLCAEJAAMCARICAiIAIgMiASIAAQAAEAQLADcAOAACAQEAAAMGCwA6AAwBESsLAQICAQAAEAMLADcAAgMBAAAQAwsANgACBAEAABAECwA3ATgBAgUBAAAQAwsANwECBgEAABADCwA2AQIHAQAAEAULAREsCwA5AQIIAQAADQYLADoBDAERKwsBAgkBAAAQBwsCESwLAAsBOAI5AQIKAQAAEAYLAAsBOAM4BAECCwEEAA0KCwE6AQwCESsLADYBCwI4BAECDAEAABAGCwA2AQsBCwI4BQINAQAAJjsKAQYAAAAAAAAAACQEBQULCwABCwIBBwEnCgEKAC44BiUEEgUYCwABCwIBBwInQAwAAAAAAAAAAAwFBgAAAAAAAAAADAMKAC44BgoBGgwEKAoDCgEGAQAAAAAAAAAXIwQ1BSoNBQoACgQKAjgHRAwLAwYBAAAAAAAAABYMAwUiCwABCwIBCwUCDgEAABAFCwARLDgIOQECDwEAAA0HCwA6AQwBESsLATgJAhABAAAQHA4AOAoEBAUICwYBBwAnCgE5AjgLCgYRLAsAOAw5AAsGESwLAQsDESALAhEeCwQRIAsFOQMCEQEAABAICwIRLAsANgALATgNOQECEgEAABAFCwA2AAsBOA0CEwEEAA0JCwE6AQwCESsLADYACwI4DgIUAQQAEAcLAAsBCwM4DwsCOBACFQEEABAFCwILATYCFQIWAQQAEAULAgsBNgMVAhcBBAAQBQsCCwE2BBUCGAEEABAHCwIRLzgRCwE2BRUCGQEAABAECwA3BhQCGgEAABAECwA3AhQCGwEAABAECwA3AxQCHAEAABAECwA3BBQCHQEAABAECwA3BRQCAgEAAQECAQMBBAEFAQEAIgEiAiIDIgQiBSIGIgAEaGFzaHGhHOsLBgAAAAYBAAIDAgoFDAcHExoILSAMTQgAAQAAAAEAAAIAAQABBgoCAQoCCmJsYWtlMmIyNTYEaGFzaAlrZWNjYWsyNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgABAgABAQIAAARobWFjZKEc6wsGAAAABgEAAgMCBQUHCgcREwgkIAxEBAAAAAEAAQACBgoCBgoCAQoCBGhtYWMNaG1hY19zaGEzXzI1NgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAAEbWF0aKcFoRzrCwYAAAAGAQACAwIjBSUSBzc5CHAgDJAB+QMAAgADAAEAAAQAAQAAAAABAAAFAgEAAAYBAQAABwMDAAABAAEAAgMDAQMCAwIBBAMEBAQDDw8PBGRpZmYTZGl2aWRlX2FuZF9yb3VuZF91cARtYXRoA21heANtaW4DcG93BHNxcnQJc3FydF91MTI4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQAAAQsKAAoBJAQHCwAMAgUJCwEMAgsCAgEBAAABCwoACgEjBAcLAAwCBQkLAQwCCwICAgEAAAEPCgAKASQECQsACwEXDAIFDQsBCwAXDAILAgIDAQAAASEGAQAAAAAAAAAMAgoBMQEmBB8FBwoBMQIZMQAhBBYKAAsAGAwACwExAhoMAQUeCwIKABgMAgsBMQEXDAEFAgsCAgQBAAAEKzIAAAAAAAAAAAEAAAAAAAAADAEyAAAAAAAAAAAAAAAAAAAAAAwCCwA1DAMKATIAAAAAAAAAAAAAAAAAAAAAIgQoBQwKAwoCCgEWJgQfCwMKAgoBFhcMAwsCMQEwCgEWDAIFIwsCMQEwDAILATECMAwBBQcLAjQCBQEAAAUrSgAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAADAFKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAgsATQwDCgFKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiBCgFDAoDCgIKARYmBB8LAwoCCgEWFwwDCwIxATAKARYMAgUjCwIxATAMAgsBMQIwDAEFBwsCNQIGAQAAARMKAAoBGQYAAAAAAAAAACEECwsACwEaDAIFEQsACwEaBgEAAAAAAAAAFgwCCwICAAVjbG9ja6IDoRzrCwYAAAALAQAIAggMAxQfBDMCBTUeB1N6CM0BIAbtASwKmQIIDKECTw3wAgIAAwAHAAsADAAACAABAgQAAwECAAAKAAEAAAUCAwAABAQDAAEDAwYAAgkIAwEIAwgCBQAEBwEGCAABAwEGCAIAAwcIAAMGCAIBBQEIAQEIAAEJAAVDbG9jawlUeENvbnRleHQDVUlEBWNsb2NrGWNvbnNlbnN1c19jb21taXRfcHJvbG9ndWUGY3JlYXRlAmlkBm9iamVjdAZzZW5kZXIMc2hhcmVfb2JqZWN0DHRpbWVzdGFtcF9tcwh0cmFuc2Zlcgp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgYIAQoDAAEAAAMECwAQABQCAQAAAAMNCwARBQcBIQQGBQgHACcRAwYAAAAAAAAAABIAOAACAgAAAAMPCwIRBQcBIQQGBQoLAAEHACcLAQsADwAVAgABAAVlY3ZyZooBoRzrCwYAAAAHAQACAwIFBQcPBxYTCCkgBkkeDGcEAAAAAQABAAQGCgIGCgIGCgIGCgIBAQVlY3ZyZgxlY3ZyZl92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAABAgAABWV2ZW50V6Ec6wsGAAAABgEAAgMCBgUIBAcMCwgXIAw3BAABAAAAAQEDAQkAAARlbWl0BWV2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQIAAAVraW9za8odoRzrCwYAAAANAQAWAhZSA2jOAgS2AzgF7gPsAwfaB/MGCM0OQAaND3gKhRBRC9YQBAzaEJkMDfMcEg6FHQYALgE3ABMAGAAbABwAHgA2AEwATgBPAAYMAAAHDAAACwwBDAEAAQAAAAQHAAAIBwAACQcAAAUDAQwBAQoHAQAAAgAEAQABAwIMAQABBwMHAAcQBAAIDAIACQ0MAQABCQ4AAQABCg8CAAA0AAEAABcCAwAASgQFAABLBgUAADkHBQEMADIIBQEMAE0JCgEMADALBQEMADoMBQEMAD8NDgEMADEPEAEMAEMRDgEMAEYSBQEMAFQTAwAAIxQVAAApFBUAACcUFQAAKBQVAAAiFhUAAFEWFwAASRgFAABQGRcAADgaGwAAKxocAAA9Gh0AAD4WHgAAFB8gAQwAFQkhAQwAFgkiAQwARyMFAQwAQSQlAQwAQCQlAQwAQiQdAQwBGkMKAQABKkIVAQACLTsdAQACU0QdAQACVQUpAQADIS4vAQADJS8pAQADTUUvAQADUzodAQAEETEFAgcEBB9HFQEHBEQ1NwIHBARFNTYCBwQFETEFAgcMBRRHSgIHDAUVNUwCBwwFH0cVAQcFRDU3AgcMBh0KBQEDBxknBQAHJCAlAQgHNAAnAAdSLSUACTU8PQEACkgqGwAlKDUrJig1Ci4wKjIECi00MjAqNDM4BwosNCkoJygjKC0yOAoJCiIdIR0kKCgoMUYrSCtJLzAwMAEHCBACCAAIAQMIAAgBBwgQAQsKAQgNAwcIAAYIAQYIEAADBwgABggBBQMHCAAGCAEJAAQHCAAGCAEGCw4BCQAJAAMHCAAGCAEICwEJAAQHCAAGCAEICwMEBwgABggBCQADAwcIAAgLCwoBCA0CCQALDwEJAAUHCAAGCAEICwMHCBABCwIBCQADBwgACwIBCQALCgEIDQIHCAALAgEJAAQHCAAGCAELCAEDBwgQAgYIAAgLAQECBwgABggBAQcIDAMHCAAGCAEBAQcIAAEGCAABBQEOAQMBBwsJAQgNAwYIAAYIAQgLAQYJAAEHCQACCQAIAwMHCAAJAAgDAQYLAgEJAAEICwIIAQgAAQgMAQgNAQsJAQkAAQYIEAEIAAUIDAgLCAwOCwkBCA0BBggMAgsJAQkABwgQAQsKAQkAAggECQADBwgMCQAJAQIIBgEDCAsICwgLAggFAwIHCAwJAAELCAEJAQEJAQELBwEJAAIJAAMBBgsKAQkAAgcLCQEJAAsJAQkAAwgLAwgLAQsPAQkABggLCAwICwgLAwgMBQgMCAsICwMDAwgMCAsICwMDAwMBBgsIAQkAAQsIAQkAAQYLCQEJAAMHCwkBCQADBwgQAQgEAgYIDAkAAQgGAQgFAQYJAQIICwgLAQcJAQdCYWxhbmNlBkJvcnJvdwRDb2luAklEBEl0ZW0KSXRlbUxpc3RlZAVLaW9zaw1LaW9za093bmVyQ2FwB0xpc3RpbmcETG9jawZPcHRpb24LUHVyY2hhc2VDYXADU1VJDlRyYW5zZmVyUG9saWN5D1RyYW5zZmVyUmVxdWVzdAlUeENvbnRleHQDVUlEA2FkZBBhbGxvd19leHRlbnNpb25zB2JhbGFuY2UGYm9ycm93CmJvcnJvd19tdXQKYm9ycm93X3ZhbBJjbG9zZV9hbmRfd2l0aGRyYXcEY29pbgZkZWxldGUMZGVzdHJveV9zb21lDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQEZW1pdAVldmVudAdleGlzdHNfA2Zvcgxmcm9tX2JhbGFuY2UKaGFzX2FjY2VzcwhoYXNfaXRlbQJpZAxpbnRvX2JhbGFuY2UMaXNfZXhjbHVzaXZlCWlzX2xpc3RlZBVpc19saXN0ZWRfZXhjbHVzaXZlbHkJaXNfbG9ja2VkB2lzX3NvbWUKaXRlbV9jb3VudAdpdGVtX2lkBGpvaW4Fa2lvc2sIa2lvc2tfaWQEbGlzdBZsaXN0X3dpdGhfcHVyY2hhc2VfY2FwBGxvY2sJbWluX3ByaWNlA25ldwtuZXdfcmVxdWVzdAZvYmplY3QGb3B0aW9uBW93bmVyBXBsYWNlDnBsYWNlX2FuZF9saXN0BXByaWNlB3Byb2ZpdHMOcHJvZml0c19hbW91bnQLcHJvZml0c19tdXQIcHVyY2hhc2URcHVyY2hhc2VfY2FwX2l0ZW0ScHVyY2hhc2VfY2FwX2tpb3NrFnB1cmNoYXNlX2NhcF9taW5fcHJpY2URcHVyY2hhc2Vfd2l0aF9jYXAGcmVtb3ZlEHJlbW92ZV9pZl9leGlzdHMTcmV0dXJuX3B1cmNoYXNlX2NhcApyZXR1cm5fdmFsBnNlbmRlchRzZXRfYWxsb3dfZXh0ZW5zaW9ucwlzZXRfb3duZXIQc2V0X293bmVyX2N1c3RvbQNzdWkEdGFrZQ90cmFuc2Zlcl9wb2xpY3kKdHhfY29udGV4dAd1aWRfbXV0EHVpZF9tdXRfYXNfb3duZXIMdWlkX3RvX2lubmVyBXZhbHVlCHdpdGhkcmF3BHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMICgAAAAAAAAADCAsAAAAAAAAAAAIFJAgMPAsJAQgNOAUrDhIBAQICJAgMIAgLAgIEJAgMLwgLLAgLMwMDAgIvCAssCAsEAgEkCAsFAgIkCAsmAQYCASQICwcCAy4ICyQICzsDBwoCCgABAAAmEwoAETY4AAoALhE5SQAAAAAIEgAMAgsAETYOAjgBEgEMAQsCCwECAQEAACwmCwATAAEMBgEMBwwFCwETAQwEDAMOBRE3CwQhBBEFFQsCAQcAJwsGSQAAAAAhBBoFHgsCAQcDJwsDETQLBRE0CwcLAjgCAgIBAAAFFQoALjgBCwEQABQhBAkFDwsAAQsCAQcAJwsCETkLAA8BFQIDAQAABRIKAC44AQsBEAAUIQQJBQ0LAAEHACcLAgsADwEVAgQBAAAFHQoALjgBCwEQABQhBAkFDQsAAQcAJwoAEAIUSQEAAAAWCgAPAhULAA8DDgI4AxIECwI4BAIFAQAABQwKAA8DDgM4AxIGCDgFCwALAQsDOAYCBgEAADNICgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ8gBBYFGgsAAQcIJwoACgIMBC4LBBERIAQjBScLAAEHBCcKAAoCDAUuCwURDgQvBTMLAAEHCycKABACFEkBAAAAFwoADwIVCgAPAwoCCRIFOAcBCwAPAwsCEgQ4CAIHAQAAJSkKAC44AQsBEAAUIQQJBQ0LAAEHACcKAAoCDAQuCwQRESAEFgUaCwABBwQnCgAPAwoCCRIFCgM4CQsALjgBCwILAzkAOAoCCAEAACUNDgI4AwwECgAKAQsCOAYLAAsBCwQLAzgLAgkBAAA5MwoADwMKAQkSBTgMDAQKAA8DCgESBDgIDAMKABACFEkBAAAAFwoADwIVCgQOAjgNIQQbBR8LAAEHAScKAA8ECwI4DjgPAQoADwMKARIGOBABCwMLAQsECwAuOAE4EQIKAQAAPjwKAC44AQoBEAAUIQQJBRELAAELBAELAQEHACcKAAoCDAUuCwURECAEGgUiCwABCwQBCwEBBwYnCwQRNgwKCwAPAwoCCBIFCgM4CQsKDAYLAgwHCwEQABQMCAsDDAkLBgsICwcLCTkBAgsBAAA/MgsBOgEMBgwEDAUMAw4COA0MBwoHCwYmBA4FEgsAAQcBJwoALjgBCwUhBBkFHQsAAQcFJwoADwMKBAgSBTgMAQoADwMKBAkSBQsHOAkLAxE0CwALBAsCOBICDAEAAEAbCwE6AQEMAwwEDAIKAC44AQsEIQQNBRELAAEHBScLAA8DCwMIEgU4DAELAhE0Ag0BAABBMQoALjgBCwEQABQhBAkFDwsAAQsDAQcAJw4COBMEJQsCOBQMBgoGCgAQBDgVJQQcBSILAAELAwEHAicLBgwEBSkKABAEOBUMBAsEDAULAA8ECwULAzgWAg4BAAAFBgsAEAMLARIEOBcCDwEAAAUGCwAQAwsBEgY4GAIQAQAAFRIKABADCgEJEgU4GQQMCwABCAwCBRALAAsBEREMAgsCAhEBAAAFBwsAEAMLAQgSBTgZAhIBAAAFCAsALjgBCwEQABQhAhMBAAAFEAoALjgBCwEQABQhBAkFDQsAAQcAJwsADwMCFAEAAAUSCgAuOAELARAAFCEECQUNCwABBwAnCwILAA8FFQIVAQAABQwKABAFFAQFBQkLAAEHBycLAA8DAhYBAAAFBAsAEAEUAhcBAAAFBAsAEAIUAhgBAAAFBAsAEAQ4FQIZAQAABRAKAC44AQsBEAAUIQQJBQ0LAAEHACcLAA8EAhoBAAAFGwoAOAELARAAFCEECAUMCwABBwAnCgAKAhEOBBEFFQsAAQcLJwsAEAMLAhIEOBoCGwEAAEssCgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ4EFQUZCwABBwsnCgAKAgwELgsEERAgBCIFJgsAAQcJJwsADwMLAhIEOBsCHAEAAEsxCgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ4EFQUZCwABBwsnCgAKAgwELgsEERAgBCIFJgsAAQcJJwoADwMKAhIEOAgLAC44AQsCEgMCHQEAAEsgCwITAwwDDAQKAC44AQsEIQQLBQ8LAAEHBScOATgDCgMhBBUFGQsAAQcKJwsADwMLAxIECwE4BAIeAQAABQQLADcAFAIfAQAABQQLADcBFAIgAQAABQQLADcCFAIBAQACAAMAAAABAAQCAQICAgMGCgcKCAoABXRhYmxlggahHOsLBgAAAA0BAAgCCBADGHMEiwEKBZUBaAf9AacBCKQDIAbEAwoKzgMIC9YDAgzYA+UBDb0FBA7BBQQAEwAKABAAFAAADAIHAQQBAgIEAAMBAgAADwABAgcEAAMCAwIHBAAEBAUCBwQABQYHAgcEABEGCAIHBAAGBAkCBwQADgoLAgcEAA0KCQIHBAAIAQMCBwQACQEDAgcGAQMOAwIHBAEEDwUCBwQBBRAHAgcEAQsPCQIHBAEREAgCBwQCBwwDAAIPAAwACg0LDQwNDg0NDQEHCAIBCwACCQAJAQMHCwACCQAJAQkACQEAAgYLAAIJAAkBCQABBgkBAgcLAAIJAAkBCQABBwkBAQkBAQEBBgsAAgkACQEBAwEIAQIJAAkBAwcIAQkACQECBggBCQACBwgBCQACCAEDBVRhYmxlCVR4Q29udGV4dANVSUQDYWRkBmJvcnJvdwpib3Jyb3dfbXV0CGNvbnRhaW5zBmRlbGV0ZQ1kZXN0cm95X2VtcHR5BGRyb3ANZHluYW1pY19maWVsZBBleGlzdHNfd2l0aF90eXBlAmlkCGlzX2VtcHR5Bmxlbmd0aANuZXcGb2JqZWN0BnJlbW92ZQRzaXplBXRhYmxlCnR4X2NvbnRleHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAAAAgIMCAESAwANAAEAAAMFCwAREAYAAAAAAAAAADkAAgEBAAADDgoANgALAQsCOAAKADcBFAYBAAAAAAAAABYLADYBFQICAQAAAwULADcACwE4AQIDAQAAAwULADYACwE4AgIEAQAACA8KADYACwE4AwwCCgA3ARQGAQAAAAAAAAAXCwA2ARULAgIFAQAAAwULADcACwE4BAIGAQAAAwQLADcBFAIHAQAAAwYLADcBFAYAAAAAAAAAACECCAEAABEOCwA6AAwCDAELAgYAAAAAAAAAACEECQULBwAnCwERDwIJAQAAAwULADoAAREPAgAAAAEADQENAAV0eXBlc2ihHOsLBgAAAAYBAAIDAgYFCAYHDhoIKCAMSAQAAQAAAAEBAgEGCQABARNpc19vbmVfdGltZV93aXRuZXNzBXR5cGVzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQIAAAZib3Jyb3f+BKEc6wsGAAAADQEACAIIGAMgOwRbCgVlUwe4AZ4BCNYCQAaWAxQKqgMTC70DAgy/A30NvAQEDsAEBAAFAQ8ADgATAAMEAQwAAAAAAAECBwEAAAIBBwADBAIAAAwAAQEMAAUCAwEMABAEBQEMAAYBBgEMAQcJBgEAAQgLBgEAAQkPBQEAARIGCQEAAgsMDQEIAwoHCAAHBgUGCAYGBgQGAgkABwgEAQsAAQkAAQcLAAEJAAIJAAgBAwcLAAEJAAkACAEAAQkAAQcIBAEFAQsCAQkAAggDCQABBwsCAQkAAQYJAAEIAwIIAwUCBwsCAQkACQAGQm9ycm93AklEBk9wdGlvbghSZWZlcmVudAlUeENvbnRleHQGYm9ycm93B2Rlc3Ryb3kMZGVzdHJveV9zb21lB2V4dHJhY3QEZmlsbBRmcmVzaF9vYmplY3RfYWRkcmVzcwJpZANuZXcDb2JqBm9iamVjdAZvcHRpb24IcHV0X2JhY2sDcmVmBHNvbWUKdHhfY29udGV4dAV2YWx1ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAACAgsFFAsCAQkAAQICEQUNCAMABgABAAAFBgsBEQkLADgAOQACAQEAAAoOCgA2ADgBDAIOAjgCDAELAgsANwEUCwESAQICAQAADh4LAhMBDAMMBA4BOAILAyEECgUOCwABBwEnCgA3ARQLBCEEFQUZCwABBwAnCwA2AAsBOAMCAwEAAAkHCwA6AAwBAQsBOAQCAAEAAAAGAQYABm9iamVjdLcIoRzrCwYAAAAMAQAIAggMAxR+BJIBBgWYASMHuwH6Agi1BEAG9QRwCuUFCwzwBYICDfIHBA/2BwgAGAEEAAMAHgAABwAAAgQAAwECAAAVAAEAABQAAgAAEwEDAAASAgMAABsEBQAACAYFAAAfBwAAACIHAwAAIQcBAAAgBwIAABYIBQAACQUGAAAPCQMBCAAFCQABCAARCQEBCAAQCQIBCAAGCQcBCAAXAgUAAAoCBgAAGQIGAAEcCQEBAAIOAQIAAw0IAgADGgQCABQCEAoUAwEGCAABCgIBBQEIAAEGCAIBCAEAAQYIAQEHCAIBBgkAAQkAAklECVR4Q29udGV4dANVSUQHYWRkcmVzcwNiY3MJYm9ycm93X2lkCmJvcnJvd191aWQFYnl0ZXMFY2xvY2sGZGVsZXRlC2RlbGV0ZV9pbXBsDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQUZnJlc2hfb2JqZWN0X2FkZHJlc3MKZnJvbV9ieXRlcwJpZAppZF9hZGRyZXNzCGlkX2J5dGVzD2lkX2Zyb21fYWRkcmVzcw1pZF9mcm9tX2J5dGVzDWlkX3RvX2FkZHJlc3MLaWRfdG9fYnl0ZXMDbmV3EW5ld191aWRfZnJvbV9oYXNoBm9iamVjdA5yZWNvcmRfbmV3X3VpZAZzZW5kZXIQc3VpX3N5c3RlbV9zdGF0ZQh0b19ieXRlcwh0cmFuc2Zlcgp0eF9jb250ZXh0DHVpZF9hc19pbm5lcg51aWRfdG9fYWRkcmVzcwx1aWRfdG9fYnl0ZXMMdWlkX3RvX2lubmVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwgAAAAAAAAAAAUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEHBQECAQ8IAAABAAAGBAsAEAA4AAIBAQAABgQLABAAFAICAQAABgQLABEVEQMCAwEAAAYDCwASAAIEAAAABgwLABEXBwMhBAYFCAcCJwcAEgASAQIFAwAABgQHARIAEgECBgEAAAYDCwAQAQIHAQAABgQLABABFAIIAQAABgULABABEAA4AAIJAQAABgULABABEAAUAgoBAAAGBQsAERYSABIBAgsBAAAGBQsAEwETABESAgwBAAAGBQsAOAEQARQCDQEAAAYECwA4ARABAg4BAAAGBQsAOAEQATgCAg8BAAAGBgsAOAEQARAAFAIQAAIAEQMAAAYGCgAREwsAEgASAQISAAIAEwACAAAAAQAACAALAAwAHQAGcHJvdmVyXaEc6wsGAAAABAEAAgcCBwgJIAYpHgAABnByb3ZlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAAdhZGRyZXNzygOhHOsLBgAAAAkBAAoCCggDEj0ETwIFURQHZYEBCOYBQAamAjYM3AJFAAEBAgEDAQsACAEABwADAAcAAA8AAQAABwEAAAAGAgAAAA0AAgAADAADAAAOAAQAAAkFBgAACgUBAAELAgMAAg0HAgEAAwUDBAAEBAICAAkAAQUBDwEKAgEIAAEIAQABAwEGCQAGU3RyaW5nB2FkZHJlc3MFYXNjaWkDYmNzBmVuY29kZQpmcm9tX2FzY2lpCmZyb21fYnl0ZXMJZnJvbV91MjU2A2hleAZsZW5ndGgDbWF4BnN0cmluZw90b19hc2NpaV9zdHJpbmcIdG9fYnl0ZXMJdG9fc3RyaW5nB3RvX3UyNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwggAAAAAAAAAA8g//////////////////////////////////////////8DCAAAAAAAAAAAAAECAAEBAgACAQIAAwEAAAUDDgA4AAIEAQAABQULABEDEQsRCAIFAQAABQQLABEEEQoCBgEAAAUCBwACBwEAAAUCBwECAAdiYWxhbmNlyAehHOsLBgAAAA4BAAQCBBADFFMEZwIFaWMHzAHgAQisAyAGzANKCpYECgugBAQMpATbAg3/BgQOgwcED4cHAgADABAAAQQBAAEAAAQBAAEBAgIAABEAAQEAAA8CAQEAAAUDBAECAAoFBgEAAAYHAQEAABMIBgEAAAsJAQEAAA0KBgEAABILBgEAAAkGCAEAAAQMBgEAAAcNCAEAAAgEAQEAAQwODwAHAwEGCwEBCQABAwEGCwABCQABCQABCwABCQACBwsAAQkAAwELAQEJAAIHCwABCQALAQEJAAACBwsBAQkACwEBCQACBwsBAQkAAwEHCwEBCQACAwYIAgILAQEJAAYIAgEGCAIBBQdCYWxhbmNlBlN1cHBseQlUeENvbnRleHQHYmFsYW5jZRZjcmVhdGVfc3Rha2luZ19yZXdhcmRzDWNyZWF0ZV9zdXBwbHkPZGVjcmVhc2Vfc3VwcGx5F2Rlc3Ryb3lfc3RvcmFnZV9yZWJhdGVzDmRlc3Ryb3lfc3VwcGx5DGRlc3Ryb3lfemVybw9pbmNyZWFzZV9zdXBwbHkEam9pbgZzZW5kZXIFc3BsaXQDc3VpDHN1cHBseV92YWx1ZQp0eF9jb250ZXh0BXZhbHVlDHdpdGhkcmF3X2FsbAR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAREDAQIBEQMAAwEDAAEAAAgECwA3ABQCAQEAAAgECwA3ARQCAgEAAAgDBgAAAAAAAAAAOQACAwEAAAgYCgEG//////////8KADcBFBcjBAkFDQsAAQcBJwoANwEUCgEWCwA2ARULATkBAgQBAAABGAsBOgEMAgoANwEUCgImBAoFDgsAAQcBJwoANwEUCgIXCwA2ARULAgIFAQAACAMGAAAAAAAAAAA5AQIGAQAAAQ8LAToBDAIKADcAFAsCFgoANgAVCwA3ABQCBwEAAAgWCgA3ABQKASYEBwULCwABBwInCgA3ABQKARcLADYAFQsBOQECCAEAAAEICgA3ABQMAQsACwE4AAIJAQAACA0OADcAFAYAAAAAAAAAACEEBwUJBwAnCwA6AQECCgAAAAgLCwERDQcEIQQGBQgHAycLADkBAgsAAAAIDAsBEQ0HBCEEBgUIBwMnCwA6AQECDAMAAAgDCwA6AAIBAAAAAAMBAwAOAAdkaXNwbGF55gqhHOsLBgAAAA0BABACEC4DPoQBBMIBFgXYAcQBB5wD3wII+wVABrsGFArPBiYL9QYGDPsGoAMNmwoGDqEKBgAOAR8AEgAaABsAIAAhACQAAAwBCAEAAQMBCAEACAMBCAEBBAcAAwIHAAMGBAAEAwwABgUCAAcHBwIBAAAAABgAAQEIABkCAQEIAAwAAwEIACMEAwEIAAkFAwEIAAsGAwEIAA8FAwEIAB0HAwEIABcICQEIACUKCwEIABMKDAEIAA0NAQEIAAoFAwEIAhAOAwEDAxgNHAADIhUWAAQUCAkBAAUcEwMBDAYeERIABxEDHgIBAAcWHwMCAQAHHRobAgEACA4LDgAODA4RAQ0XFRkQDg0dExkUGQIGCAYHCAcBCwABCQAEBggGCggDCggDBwgHAAEHCwABCQADBwsAAQkACAMIAwMHCwABCQAKCAMKCAMCBwsAAQkACAMBBggGAQEBBgsAAQkAAQ0BBgsIAggDCAMBBwgHAQkAAwsAAQkAAwMBCAMBBggHAQUCCQAFAg0LCAIIAwgDAQYIBQEIBAELAgEJAAIDAwIIAwgDAgcLCAIJAAkBBgkAAgkACQEBCAUBCwEBCQABCwgCCQAJAQMHCwgCCQAJAQkACQEHRGlzcGxheQ5EaXNwbGF5Q3JlYXRlZAJJRAlQdWJsaXNoZXIGU3RyaW5nCVR4Q29udGV4dANVSUQGVmVjTWFwDlZlcnNpb25VcGRhdGVkA2FkZAxhZGRfaW50ZXJuYWwMYWRkX211bHRpcGxlD2NyZWF0ZV9hbmRfa2VlcA9jcmVhdGVfaW50ZXJuYWwHZGlzcGxheQRlZGl0BGVtaXQFZW1wdHkFZXZlbnQGZmllbGRzDGZyb21fcGFja2FnZQJpZAZpbnNlcnQNaXNfYXV0aG9yaXplZANuZXcPbmV3X3dpdGhfZmllbGRzBm9iamVjdAdwYWNrYWdlD3B1YmxpY190cmFuc2ZlcgZyZW1vdmUGc2VuZGVyBnN0cmluZwh0cmFuc2Zlcgp0eF9jb250ZXh0DHVpZF90b19pbm5lcg51cGRhdGVfdmVyc2lvbgd2ZWNfbWFwB3ZlcnNpb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAAAAgMVCAUTCwgCCAMIAyUNAQIBFQgEAgIDFQgEJQ0TCwgCCAMIAwIOAQ4ADgABAAADCwsAOAAEBAUICwEBBwAnCwE4AQIBAQAADysOAUEQDAYKBg4CQRAhBAkFDwsAAQsDAQcBJwYAAAAAAAAAAAwFCwALAzgCDAQKBQoGIwQpBRoNBA4BCgVCEBQOAgoFQhAUOAMLBQYBAAAAAAAAABYMBQUVCwQCAgEEAAMICwAKATgCCwEuERI4BAIDAQQAFBgKADcAFEgBABYKADYAFQoANwAUDAEKADcBFAwCCwA3AhEPCwELAjkAOAUCBAEEAAMFCwALAQsCOAMCBQEEABgmDgFBEAwECgQOAkEQIQQJBQ0LAAEHAScGAAAAAAAAAAAMAwoDCgQjBCMFFAoADgEKA0IQFA4CCgNCEBQ4AwsDBgEAAAAAAAAAFgwDBQ8LAAECBgEEAAMLCgA2AQ4BOAYBAQsACwELAjgDAgcBBAADBwsANgEOATgGAQECCAEAAAMDCwA4BwIJAQAAAwQLADcAFAIKAQAAAwMLADcBAgsAAAAcDAsAEQ4MAQ4BEQ85ATgICwE4CUgAADkCAgwAAAADBgsANgELAQsCOAoCAAIAAQAAAA4BDgIOAAdlZDI1NTE5aqEc6wsGAAAABgEAAgMCBQUHDAcTFwgqIAxKBAAAAAEAAQADBgoCBgoCBgoCAQEHZWQyNTUxOQ5lZDI1NTE5X3ZlcmlmeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAAHZ3JvdGgxNs0GoRzrCwYAAAAKAQACAgIQAxIyBURMB5AB7QII/QMgBp0EHgq7BCAM2wS0AQ2PBg4ACgAABwAAAQcAAAMHAAACBwAABQABAAAGAAEAABACAwAAEQMEAAAPBQYAAA4FBwAADAgDAAANCQMAABIKCwAAEwwLAAABCAAECgIKAgoCCgIBCAEBCgoCAQoCAQgCAQgDAgYIAAYKAgICBgoCBAYIAAYIAQYIAgYIAwEBBwIGCgIGCgIGCgIGCgIGCgIGCgIFQ3VydmUUUHJlcGFyZWRWZXJpZnlpbmdLZXkLUHJvb2ZQb2ludHMRUHVibGljUHJvb2ZJbnB1dHMWYWxwaGFfZzFfYmV0YV9nMl9ieXRlcwhibHMxMjM4MQVibjI1NAVieXRlcxVkZWx0YV9nMl9uZWdfcGNfYnl0ZXMVZ2FtbWFfZzJfbmVnX3BjX2J5dGVzB2dyb3RoMTYCaWQVcHJlcGFyZV92ZXJpZnlpbmdfa2V5HnByZXBhcmVfdmVyaWZ5aW5nX2tleV9pbnRlcm5hbBdwcm9vZl9wb2ludHNfZnJvbV9ieXRlcx5wdWJsaWNfcHJvb2ZfaW5wdXRzX2Zyb21fYnl0ZXMOcHZrX2Zyb21fYnl0ZXMMcHZrX3RvX2J5dGVzFHZlcmlmeV9ncm90aDE2X3Byb29mHXZlcmlmeV9ncm90aDE2X3Byb29mX2ludGVybmFsFXZrX2dhbW1hX2FiY19nMV9ieXRlcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAAIBCwIBAgQUCgIECgIJCgIICgICAgEHCgIDAgEHCgIAAQAAAAMxABIAAgEBAAAAAzEBEgACAgEAAAAGCwALAQsCCwMSAQIDAQAABBhABQAAAAAAAAAADAENAQ4AEAAURAUNAQ4AEAEURAUNAQ4AEAIURAUNAQ4AEAMURAULAQIEAQAAAAMLABICAgUBAAAAAwsAEgMCBgEAAAAGCwAQBBQLAREHAgcAAgAIAQAAABELABAEFAoBEAAKARABCgEQAgsBEAMLAhAFCwMQBhEJAgkAAgABAAEBAQIBAwAAAgADAAAHcGFja2FnZf8NoRzrCwYAAAALAQAOAg4kAzK3AQTpAQoF8wF2B+kC/gQI5wdABqcIXQqECTAMtAmBBA21DRQAJAEKATIAIQAwADEAMwABDAAABgwAAAgAAAAHAAABAgcAAgQHAAMABwADBQQABQMCAAAOAAEBAgAPAAIBAgAMAQIAABYDBAEAABUDBAEAACcDBQAAKAMFAAA0BgcAADYGCAAANQYJAAAuCgcAAC8KCQAAKQsHAAAqCwcAAC0KDAAAEQIJAAAJAgkAABMCCQAAIg0CAAAjDQIAAB4OAgAACw8QAAAQEQIAACsSAgACFwITAQACGBgZAAIZGBkAAxIXAgADGhUHAQgDGxsHAAMcHxsAAyAWFwAEJhwCAQwFLBobAAYdFQQBAiIUGBQAFCABHA4CCQAHCAgBCAAAAQYIAAEBAQYIBAEGCAEBCAYBAwECAQYIAgEGCAMBBgoCAQcIAQEIAQMHCAECCgIBCAICBwgBCAMCBwgBAgEIBQEJAAEGCQABBwgIAQgHAQYIBQEIBAEGCAgBBQIJAAUCAQgFAggGCAYBBggGAklECVB1Ymxpc2hlcgZTdHJpbmcJVHhDb250ZXh0CFR5cGVOYW1lA1VJRApVcGdyYWRlQ2FwDlVwZ3JhZGVSZWNlaXB0DVVwZ3JhZGVUaWNrZXQPYWRkaXRpdmVfcG9saWN5BWFzY2lpEWF1dGhvcml6ZV91cGdyYWRlDmJ1cm5fcHVibGlzaGVyA2NhcAVjbGFpbQ5jbGFpbV9hbmRfa2VlcA5jb21taXRfdXBncmFkZRFjb21wYXRpYmxlX3BvbGljeQZkZWxldGUPZGVwX29ubHlfcG9saWN5BmRpZ2VzdAtmcm9tX21vZHVsZQxmcm9tX3BhY2thZ2UDZ2V0C2dldF9hZGRyZXNzCmdldF9tb2R1bGUCaWQPaWRfZnJvbV9hZGRyZXNzDWlkX3RvX2FkZHJlc3MTaXNfb25lX3RpbWVfd2l0bmVzcw5tYWtlX2ltbXV0YWJsZQttb2R1bGVfbmFtZQNuZXcGb2JqZWN0Fm9ubHlfYWRkaXRpdmVfdXBncmFkZXMRb25seV9kZXBfdXBncmFkZXMHcGFja2FnZQZwb2xpY3kPcHVibGljX3RyYW5zZmVyEHB1Ymxpc2hlZF9tb2R1bGURcHVibGlzaGVkX3BhY2thZ2ULcmVjZWlwdF9jYXAPcmVjZWlwdF9wYWNrYWdlCHJlc3RyaWN0BnNlbmRlcg10aWNrZXRfZGlnZXN0DnRpY2tldF9wYWNrYWdlDXRpY2tldF9wb2xpY3kIdHJhbnNmZXIKdHhfY29udGV4dAl0eXBlX25hbWUFdHlwZXMPdXBncmFkZV9wYWNrYWdlDnVwZ3JhZGVfcG9saWN5B3ZlcnNpb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAACAQACAYACAcAFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDGggHJAgEHwgEAQIEGggHJAgGNgMlAgICBA0IBiQIBiUCFAoCAwICDQgGJAgGAAEAABMSDgA4AAQEBQgLAQEHACc4AQwCCwERHw4CERkOAhEaEgACAQEAAAIICwAKATgCCwEuESE4AwICAQAAAgYLABMAAQERGwIDAQAAEwk4AQwBDgERGQsAEAAUIQIEAQAAHRc4AQwCDgIRGQoAEAAUIQQRDgIRGgsAEAEUIQwBBRULAAEJDAELAQIFAQAAAgMLABABAgYBAAACAwsAEAACBwEAAAIECwAQAhQCCAEAAAIECwAQAxQCCQEAAAIECwAQBBQCCgEAAAIECwAQBRQCCwEAAAIECwAQBhQCDAEAAAIECwAQBxQCDQEAAAIECwAQCBQCDgEAAAIDCwAQCQIPAQAAAgIHBQIQAQAAAgIHBgIRAQAAAgIHBwISAQQAAgQLAAcGERcCEwEEAAIECwAHBxEXAhQBBAACBwsAEwEBAQERGwIVAQAAHikHCBEdDAMKABACFAoDIgQKBQ4LAAEHAicKAQoAEAQUJgQVBRkLAAEHAScKABACFAwECwMKAA8CFQsALjgECwQLAQsCEgICFgEAAB4nCwETAwwDDAIKAC44BAsCIQQLBQ8LAAEHBCcKABACER4HCCEEFgUaCwABBwMnCwMKAA8CFQoAEAMUBgEAAAAAAAAAFgsADwMVAhcAAAACEAoAEAQUCgElBAcFCwsAAQcBJwsBCwAPBBUCAAEAAgEBAQIBAwIBAgIDAAMBAgMAB3ZlY19tYXC4DaEc6wsGAAAADQEABgIGFgMcqAEExAEcBeAB/gEH3gOZAgj3BUAGtwYyCukGFQv+BgQMggfrBQ3tDAYO8wwGAB4BFQEfAAIHAgEAAAAAAAcCAQAAAAEBBwEAAAAHAAECAQAADgIAAgEAABcDBAIBAAAWBQQCAQAADQMGAgEAAAgHCAIBAAAcBwkCAQEAAwcKAgEAABoLDAIBAAAQCwoCAQAABQEAAgEAAA8BDQIBAAATCw4CAQAADAcPAgEAAAsHDAIBAAAJEBECAQAAChITAgEAABgSBAIBAAEGGxgBAAERHAoBAAEUABsBAAEbGBsBAAIQGQoBAAIXFxgBAAIZHwABAAcEDgQXFBYUBQQVGhQaDQQTDAgEGBQVDBQMEgwAAQsAAgkACQEDBwsAAgkACQEJAAkBAgcLAAIJAAkBBgkAAgkACQEBBwsAAgkACQEBBwkBAgYLAAIJAAkBBgkAAQYJAQELAgEJAQEBAQYLAAIJAAkBAQMCCgkACgkBAQoJAAELAgEDAgYLAAIJAAkBAwIGCQAGCQECBwsAAgkACQEDAgYJAAcJAQELAQIJAAkBAQYJAAIGCQADAgcKCQADAQkAAQYKCQABCQEBCwIBCQABBgsCAQkAAQoLAQIJAAkBBwoLAQIJAAkBAwkACgkAAwkBCgkBAQcKCQAEBgsBAgkACQEDCgkAAwIDAwEGCwECCQAJAQEHCwECCQAJAQVFbnRyeQZPcHRpb24GVmVjTWFwCGNvbnRhaW5zCGNvbnRlbnRzDWRlc3Ryb3lfZW1wdHkMZGVzdHJveV9zb21lBWVtcHR5A2dldBBnZXRfZW50cnlfYnlfaWR4FGdldF9lbnRyeV9ieV9pZHhfbXV0B2dldF9pZHgLZ2V0X2lkeF9vcHQHZ2V0X211dAZpbnNlcnQQaW50b19rZXlzX3ZhbHVlcwhpc19lbXB0eQdpc19zb21lA2tleQRrZXlzBG5vbmUGb3B0aW9uA3BvcAZyZW1vdmUTcmVtb3ZlX2VudHJ5X2J5X2lkeAdyZXZlcnNlBHNpemUEc29tZQd0cnlfZ2V0BXZhbHVlB3ZlY19tYXAGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAAIBBAoLAQIJAAkBAQICEgkAHQkBAAQBBAABAAAAA0AUAAAAAAAAAAA5AAIBAQAAFRQKAA4BDAMuCwM4ACAECQUNCwABBwAnCwA2AAsBCwI5AUQUAgIBAAAWDQoACwEMAi4LAjgBDAMLADYACwM4AjoBAgMBAAAADwoANwA4AyAEBgUKCwABBwQnCwA2AEUUOgECBAEAABYNCgALAQwCLgsCOAEMAwsANgALA0MUNgECBQEAAAwKCgALATgBDAILADcACwJCFDcBAgYBAAAJEwoACgE4AAQLCwALATgEFDgFDAIFEQsAAQsBATgGDAILAgIHAQAADwcLAAsBOAcMAg4COAgCCAEAAAAECwA3AEEUAgkBAAAABQsAOAkGAAAAAAAAAAAhAgoBAAAdDAsAOgAMAQ4BOAMEBwUJBwInCwFGFAAAAAAAAAAAAgsBAAAeKAsAOgAMAQ0BOAoGAAAAAAAAAAAMAg4BQRQMBUAYAAAAAAAAAAAMBEAaAAAAAAAAAAAMBwoCCgUjBCMFEw0BRRQ6AQwGDAMNBAsDRBgNBwsGRBoLAgYBAAAAAAAAABYMAgUOCwFGFAAAAAAAAAAACwQLBwIMAQAAICAGAAAAAAAAAAAMAgoANwBBFAwEQBgAAAAAAAAAAAwDCgIKBCMEHAUNCgA3AAoCQhQMAQ0DCwE3AhREGAsCBgEAAAAAAAAAFgwCBQgLAAELAwINAQAAISQGAAAAAAAAAAAMAgoAOAkMAwoCCgMjBB4FCgoANwAKAkIUNwIKASEEGQsAAQsBAQsCOAsCCwIGAQAAAAAAAAAWDAIFBQsAAQsBATgMAg4BAAAPDQsACwE4BwwCDgI4CAQIBQoHAScLAjgNAg8BAAAiFAoBCgA4CSMEBgUKCwABBwMnCwA3AAsBQhQMAgoCNwILAjcBAhABAAAjFQoBCgAuOAkjBAcFCwsAAQcDJwsANgALAUMUDAIKAjcCCwI2AQIRAQAAABEKAQoALjgJIwQHBQsLAAEHAycLADYACwE4AjoBAgAAAQEBAAAEAQQCBAAHdmVjX3NldK0GoRzrCwYAAAANAQAGAgYMAxJgBHIUBYYBWgfgAZ8BCP8CQAa/AxQK0wMHC9oDAgzcA5ECDe0FAg7vBQIAEgENARMAAQcBAwABAAcBAAAABQABAQMADwIBAQMACAMAAQMADgQAAQMAAgUGAQMAEAcIAQMACgcGAQMACQEJAQMABwUKAQMABgUIAQMBBBACAQABCw4GAQABDAAQAQABEQIQAQACDg0CAQACDwIJAQAPAgQCCQIOAggCCwgFAg0IDAgKCAABCwABCQABCQACBwsAAQkACQACBwsAAQkABgkAAgYLAAEJAAYJAAEBAQYLAAEJAAEDAQoJAAELAQEDAQYJAAIGCQADAgcKCQADAQYLAQEJAAIDAwELAQEJAAZPcHRpb24GVmVjU2V0CGNvbnRhaW5zCGNvbnRlbnRzDGRlc3Ryb3lfc29tZQVlbXB0eQdnZXRfaWR4C2dldF9pZHhfb3B0Bmluc2VydAlpbnRvX2tleXMIaXNfZW1wdHkHaXNfc29tZQRub25lBm9wdGlvbgZyZW1vdmUJc2luZ2xldG9uBHNpemUEc29tZQd2ZWNfc2V0BnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAACAQMKCQAAAgABAAAAA0ACAAAAAAAAAAA5AAIBAQAAAAQLADgAOQACAgEAAAsSCgAOAQwCLgsCOAEgBAkFDQsAAQcAJwsANgALAUQCAgMBAAAMDQoACwEMAi4LAjgCDAMLADYACwM4AwECBAEAAAoHCwALATgEDAIOAjgFAgUBAAAABAsANwBBAgIGAQAAAAULADgGBgAAAAAAAAAAIQIHAQAAAAMLADoAAggAAAAPIwYAAAAAAAAAAAwCCgA4BgwDCgIKAyMEHQUKCgA3AAoCQgIKASEEGAsAAQsBAQsCOAcCCwIGAQAAAAAAAAAWDAIFBQsAAQsBATgIAgkAAAAKDQsACwE4BAwCDgI4BQQIBQoHAScLAjgJAgAAAAIACGJsczEyMzgxlAGhHOsLBgAAAAYBAAIDAgoFDAwHGDgIUCAMcAgAAAACAAEAAAEAAQADBgoCBgoCBgoCAQEIYmxzMTIzODEWYmxzMTIzODFfbWluX3BrX3ZlcmlmeRdibHMxMjM4MV9taW5fc2lnX3ZlcmlmeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAEBAgAACGVjZHNhX2sx1AGhHOsLBgAAAAcBAAIDAg8FERwHLUAIbSAGjQEaDKcBDAABAAIAAQAAAAIBAAADAwQAAwYKAgYKAgIBCgIBBgoCBAYKAgYKAgYKAgIBARFkZWNvbXByZXNzX3B1YmtleQhlY2RzYV9rMRNzZWNwMjU2azFfZWNyZWNvdmVyEHNlY3AyNTZrMV92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAgEAAgEBAAECAAEBAgACAQIAAAhlY2RzYV9yMbQBoRzrCwYAAAAHAQACAwIKBQwYByQuCFIgBnIaDIwBCAAAAAEAAQAAAgIDAAMGCgIGCgICAQoCBAYKAgYKAgYKAgIBAQhlY2RzYV9yMRNzZWNwMjU2cjFfZWNyZWNvdmVyEHNlY3AyNTZyMV92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAgEAAgEBAAECAAEBAgAACHRyYW5zZmVy+AKhHOsLBgAAAAgBAAIDAjYEOAYFPggHRpABCNYBIAb2AQoMgAJSAAcABwABAQgABAABAQwAAAIBAQgAAgIBAQwABQIBAQgAAwIBAQwAAQIBAQgABgIBAQgACAABAQgIAgYCBwICCQAFAAEJAA1mcmVlemVfb2JqZWN0EmZyZWV6ZV9vYmplY3RfaW1wbBRwdWJsaWNfZnJlZXplX29iamVjdBNwdWJsaWNfc2hhcmVfb2JqZWN0D3B1YmxpY190cmFuc2ZlcgxzaGFyZV9vYmplY3QRc2hhcmVfb2JqZWN0X2ltcGwIdHJhbnNmZXINdHJhbnNmZXJfaW1wbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAABAAABBAsACwE4AAIBAQAAAQQLAAsBOAACAgEAAAEDCwA4AQIDAQAAAQMLADgBAgQBAAABAwsAOAICBQEAAAEDCwA4AgIGAwIABwMCAAgDAgAACXRhYmxlX3ZlY7IGoRzrCwYAAAANAQAGAgYSAxhnBH8UBZMBigEHnQKfAQi8AyAG3AMUCvADCgv6AwIM/AP1AQ3xBQIO8wUCABEAEAASAAEEAQQBAQAMAgcBBAECAgIAAAgAAQEEAA8CAQEEAAoDBAEEAAkDBQEEAAQGBwEEAA0ICQEEAAUKCwEEAAwMDQEEAAcBCQEEAQMTCQIHBAEEERICBwQBBRQVAgcEAQcPCQIHBAEKEAQCBwQBCwAPAgcEAQ4UFgIHBA4OAA0FDQ0OAg0KDgkOCw4PDgwOAQcIAgELAAEJAAIJAAcIAgEGCwABCQABAwEBAgYLAAEJAAMBBgkAAgcLAAEJAAkAAAIHCwABCQADAQcJAAEHCwABCQABCQACAwkAAQsBAgkACQEBBgsBAgkACQECBgsBAgkACQEJAAEGCQEDBwsBAgkACQEJAAkBAgcLAQIJAAkBCQABBwkBAQkBBVRhYmxlCFRhYmxlVmVjCVR4Q29udGV4dANhZGQGYm9ycm93CmJvcnJvd19tdXQIY29udGVudHMNZGVzdHJveV9lbXB0eQVlbXB0eQhpc19lbXB0eQZsZW5ndGgDbmV3CHBvcF9iYWNrCXB1c2hfYmFjawZyZW1vdmUJc2luZ2xldG9uBXRhYmxlCXRhYmxlX3ZlYwp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAACAQYLAQIDCQAADQABAAAJBAsAOAA5AAIBAQAAAQgLATgBDAINAgsAOAILAgICAQAACQQLADcAOAMCAwEAAAkFCwA4BAYAAAAAAAAAACECBAEAAAkPCgA4BAoBJAQGBQoLAAEHACcLADcACwE4BQIFAQAABAoKAC44BAwCCwA2AAsCCwE4BgIGAQAACRAKAC44BAoBJAQHBQsLAAEHACcLADYACwE4BwIHAQAABBQKAC44BAwBCgEGAAAAAAAAAAAkBAkFDQsAAQcAJwsANgALAQYBAAAAAAAAABc4CAIIAQAACQwOADgEBgAAAAAAAAAAIQQGBQgHAScLADoAOAkCAAAADQAJdmVyc2lvbmVk/gWhHOsLBgAAAAsBAAgCCBQDHFUEcQoFe2EH3AHsAQjIAyAG6AMKCvIDEAyCBMUBDccFBAAXAAsAEAAUAAQMAAADAAACAAcAAgIEAAMBAgAACAABAQQAFgIDAAANAgQBBAAOBQYBBAATBQcBBAAVCAkBBAAKAQoBBAEFDgkCBwQBBg8QAgcEAQcREgIHBAESERMCBwQCCQwJAAIMBBQBCAIPCwwABw0IDQkNCg0MAQMDCQAHCAQBCAABBggAAQMBBgkAAQcIAAEHCQACCQAIAQQHCAADCQAIAQABCQABBwgEAQgDAgMJAAMHCAMJAAkBAgYIAwkAAQYJAQIHCAMJAAEHCQEBCQEBCAIDCAMJAAMCSUQJVHhDb250ZXh0A1VJRBBWZXJzaW9uQ2hhbmdlQ2FwCVZlcnNpb25lZANhZGQGYm9ycm93CmJvcnJvd19tdXQGY3JlYXRlBmRlbGV0ZQdkZXN0cm95DWR5bmFtaWNfZmllbGQCaWQKbG9hZF92YWx1ZQ5sb2FkX3ZhbHVlX211dANuZXcGb2JqZWN0C29sZF92ZXJzaW9uBnJlbW92ZRhyZW1vdmVfdmFsdWVfZm9yX3VwZ3JhZGUKdHhfY29udGV4dAd1cGdyYWRlB3ZlcnNpb24JdmVyc2lvbmVkDHZlcnNpb25lZF9pZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAACAgwIAxYDAQICGAgCEQMAAQAAAQwLAhENCgASAAwDDQMPAAsACwE4AAsDAgEBAAAJBAsAEAEUAgIBAAAJBwoAEAALABABFDgBAgMBAAAJBwoADwALABABFDgCAgQBAAAJDgoADwAKABABFDgDCgAuOAQLABABFBIBAgUBAAADIAsDEwEMBAoALjgEIQQJBQ0LAAEHACcLBAoBIwQSBRYLAAEHACcKAA8ACgELAjgACwELAA8BFQIGAQAAFQwLABMADAMMAQ0BCwM4AwwCCwERCwsCAgAAAAEACm9iamVjdF9iYWfpBqEc6wsGAAAACwEACgIKFgMgfAScAQ4FqgFYB4IC5wEI6QNABqkECgqzBAgMuwT1AQ2wBgQAFAEVAAwAEwAYAAEMAAECBwEAAAMABwADBAQABAMCAAASAAEAAAUCAwIHDAAGBAUCBwwABwYHAgcMABYGCAIHDAAIBAkBBwAJBAkCBwwAEQoLAAAQCgkAAAsBAwAAGQQMAQcCBQ8DAgcMAgYQBQIHDAIHEQcCBwwCDRAJAQcCDhAJAgcMAg8QDAEHAhYRCAIHDAMKDQMAAxIADQALDgwODQ4RDg4SDw4QEgEHCAQBCAADBwgACQAJAQACBggACQABBgkBAgcIAAkAAQcJAQEJAQEBAQYIAAEDAQsBAQgCAQgDAgkACQEDBwgDCQAJAQIGCAMJAAIHCAMJAAEJAAIIAwMCSUQJT2JqZWN0QmFnBk9wdGlvbglUeENvbnRleHQDVUlEA2FkZAZib3Jyb3cKYm9ycm93X211dAhjb250YWlucxJjb250YWluc193aXRoX3R5cGUGZGVsZXRlDWRlc3Ryb3lfZW1wdHkUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlAmlkCGlzX2VtcHR5Bmxlbmd0aANuZXcGb2JqZWN0Cm9iamVjdF9iYWcGb3B0aW9uBnJlbW92ZQRzaXplCnR4X2NvbnRleHQIdmFsdWVfaWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAACAg8IAxcDAAEAAAMFCwAREwYAAAAAAAAAABIAAgEBAAADDgoADwALAQsCOAAKABABFAYBAAAAAAAAABYLAA8BFQICAQAAAwULABAACwE4AQIDAQAAAwULAA8ACwE4AgIEAQAACA8KAA8ACwE4AwwCCgAQARQGAQAAAAAAAAAXCwAPARULAgIFAQAAAwULABAACwE4BAIGAQAAAwULABAACwE4BQIHAQAAAwQLABABFAIIAQAAAwYLABABFAYAAAAAAAAAACECCQEAABMOCwATAAwCDAELAgYAAAAAAAAAACEECQULBwAnCwEREgIKAQAAAwULABAACwE4BgIAAAABAAp0eF9jb250ZXh0+QKhHOsLBgAAAAoBAAICAgQDBh4FJBQHOGgIoAEgBsABFArUAQ4M4gFgDcICCgAHAAACAAAGAAEAAAIAAgAAAwACAAAEAwEAAAUAAgAAAQQBAAEGCAABBQEDAQcIAAIKAgMAAgUDCVR4Q29udGV4dAlkZXJpdmVfaWQFZXBvY2gSZXBvY2hfdGltZXN0YW1wX21zFGZyZXNoX29iamVjdF9hZGRyZXNzC2lkc19jcmVhdGVkBnNlbmRlcgp0eF9jb250ZXh0B3R4X2hhc2gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIIAAAAAAAAAADCAAAAAAAAAAAAAIFBgUICgICAwMDBQMAAQAABQQLABAAFAIBAQAABQQLABABFAICAQAABQQLABACFAIDAQAABhIKABADFAwCCgAQBBQKAhEFDAELAgYBAAAAAAAAABYLAA8DFQsBAgQAAAAFBAsAEAMUAgUAAgAAAAACAAMABAABAAxsaW5rZWRfdGFibGWRDaEc6wsGAAAADQEACgIKHgMo1AEE/AEcBZgCvAEH1APNAgihBkAG4QYUCvUGJgubBwQMnweXBQ22DA4OxAwOABgBHQAOABwAKAAADAIHAAQBAAEEAgcABAABAgcBAAADBAQABAMCAAAZAAECBwQAEQIDAgcEAAYCAwIHBAAiBAUCBwQAIQQFAgcEAAcGBwIHBAAICAkCBwQAIAYDAgcEABoGAwIHBAAjCAoCBwQAHwsMAgcEAB4LDAIHBAAJBg0CBwQAFwIOAgcEABQCDQIHBAALAQUCBwQADQEFAgcGAQcDGQEAAQwREAEAARATBQEAARUDDQEAARYDDQEAARsFEQEAASUQEQEAASYTEQEAAgUWBQIHBAIHFwcCBwQCCBUJAgcEAg8XDQIHBAIjFQoCBwQDCg8FAAMZAA8AFhAYEBQQExAVEBIQFxAbFBkUGhQdFBEQCQwcFAEHCAQBCwACCQAJAQEGCwACCQAJAQEGCwIBCQADBwsAAgkACQEJAAkBAAIGCwACCQAJAQkAAQYJAQIHCwACCQAJAQkAAQcJAQEJAQEHCwACCQAJAQIJAAkBAQEBAwEIAwEJAAELAgEJAAULAgEJAAsCAQkACwIBCQAJAAsCAQkAAgcLAgEJAAkAAgkACwECCQAJAQIHCAMJAAMHCAMJAAkBAgYIAwkAAwsCAQkACwIBCQAJAQEGCQACCAMDC0xpbmtlZFRhYmxlBE5vZGUGT3B0aW9uCVR4Q29udGV4dANVSUQDYWRkBGJhY2sGYm9ycm93CmJvcnJvd19tdXQIY29udGFpbnMGZGVsZXRlDWRlc3Ryb3lfZW1wdHkMZGVzdHJveV9zb21lBGRyb3ANZHluYW1pY19maWVsZBBleGlzdHNfd2l0aF90eXBlBGZpbGwFZnJvbnQEaGVhZAJpZAhpc19lbXB0eQdpc19ub25lB2lzX3NvbWUGbGVuZ3RoDGxpbmtlZF90YWJsZQNuZXcEbmV4dARub25lBm9iamVjdAZvcHRpb24IcG9wX2JhY2sJcG9wX2Zyb250BHByZXYJcHVzaF9iYWNrCnB1c2hfZnJvbnQGcmVtb3ZlBHNpemUEc29tZQxzd2FwX29yX2ZpbGwEdGFpbAp0eF9jb250ZXh0BXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAAIEEwgDJAMSCwIBCQAnCwIBCQABAgMgCwIBCQAaCwIBCQApCQEADAEMAAEAAAUHCwARHwYAAAAAAAAAADgAOAA5AAIBAQAABQMLADcAAgIBAAAFAwsANwECAwEAABI2CgA2AAoBOAEMBQoANwE4AgQNCgA2AQoBOAM4AAwHDgU4BAQhCwU4BQwGCgE4BgoANgIKBjgHNgMVCwY4BgwDBSM4AAwDCwMMBAoANgILAQsHCwQLAjkBOAgKADcEFAYBAAAAAAAAABYLADYEFQIEAQAAEjYKADcAOAIECAoANgAKATgDCgA2AQoBOAEMBQ4FOAQEHwsFOAUMBgoBOAYKADYCCgY4BzYFFQsGOAYMAwUhOAAMAwsDDAc4AAwECgA2AgsBCwcLBAsCOQE4CAoANwQUBgEAAAAAAAAAFgsANgQVAgUBAAAFBgsANwILATgJNwYCBgEAAAUGCwA2AgsBOAc2BgIHAQAABQYLADcCCwE4CTcDAggBAAAFBgsANwILATgJNwUCCQEAABhBCgA2AgoBOAo6AQwEDAIMAwoANwQUBgEAAAAAAAAAFwoANgQVDgM4BAQcCgIKADYCDgM4CxQ4BzYFFQ4COAQEKAoDCgA2Ag4COAsUOAc2AxUKADcAOAsOASEEMgsCCgA2ABUKADcBOAsOASEEPQsDCwA2ARUFPwsAAQsEAgoBAAAQEwoANwA4BAQFBQkLAAEHAScKADcAOAsUDAEKAQsACwE4DAILAQAAEBMKADcBOAQEBQUJCwABBwEnCgA3ATgLFAwBCgELAAsBOAwCDAEAAAUFCwA3AgsBOA0CDQEAAAUECwA3BBQCDgEAAAUGCwA3BBQGAAAAAAAAAAAhAg8BAAAaEAsAOgABAQwCDAELAgYAAAAAAAAAACEECwUNBwAnCwERHgIQAQAABQcLADoAAQEBER4CAAIAAwAAAQAAAQEBAQIADAEMAgwDDAQMBQwGDAAMb2JqZWN0X3RhYmxl3wahHOsLBgAAAA0BAAoCChoDJHgEnAEMBagBcQeZAscBCOADQAagBAoKqgQIC7IEAgy0BOYBDZoGBA6eBgQAEgETAAsAEQAWAAEMAgcBDAEBAgcBAAADAAcAAwQEAAQDAgAAEAABAgcMAAUCAwIHDAAGBAUCBwwABwYHAgcMABQGCAIHDAAIBAkCBwwADwoLAgcMAA4KCQIHDAAKAQMCBwwAFwQMAgcMAgUPAwIHDAIGEAUCBwwCBxEHAgcMAgwQCQEHAg0QDAEHAhQRCAIHDAMJDQMAAxAADQAKDgsODA4PDg0SDhIBBwgEAQsAAgkACQEDBwsAAgkACQEJAAkBAAIGCwACCQAJAQkAAQYJAQIHCwACCQAJAQkAAQcJAQEJAQEBAQYLAAIJAAkBAQMBCwEBCAIBCAMCCQAJAQMHCAMJAAkBAgYIAwkAAgcIAwkAAQkAAggDAwJJRAtPYmplY3RUYWJsZQZPcHRpb24JVHhDb250ZXh0A1VJRANhZGQGYm9ycm93CmJvcnJvd19tdXQIY29udGFpbnMGZGVsZXRlDWRlc3Ryb3lfZW1wdHkUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXwJpZAhpc19lbXB0eQZsZW5ndGgDbmV3Bm9iamVjdAxvYmplY3RfdGFibGUGb3B0aW9uBnJlbW92ZQRzaXplCnR4X2NvbnRleHQIdmFsdWVfaWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAACAg0IAxUDAA4AAQAAAwULABERBgAAAAAAAAAAOQACAQEAAAMOCgA2AAsBCwI4AAoANwEUBgEAAAAAAAAAFgsANgEVAgIBAAADBQsANwALATgBAgMBAAADBQsANgALATgCAgQBAAAIDwoANgALATgDDAIKADcBFAYBAAAAAAAAABcLADYBFQsCAgUBAAADBQsANwALATgEAgYBAAADBAsANwEUAgcBAAADBgsANwEUBgAAAAAAAAAAIQIIAQAAEw4LADoADAIMAQsCBgAAAAAAAAAAIQQJBQsHACcLAREQAgkBAAADBQsANwALATgFAgAAAAEADgEOAA1keW5hbWljX2ZpZWxklgqhHOsLBgAAAA4BAAYCBhYDHIUBBKEBGAW5AagBB+ECgQMI4gVABqIGKArKBgwL1gYCDNgG6wINwwkGDskJCA/RCQIACwEaABkAAAgCBwAEAAECBwEAAAIBBwACAwQAAAQAAQIHBAAGAgMCBwQACQQFAgcEABsEBgIHBAANAgcBBwAdBAgCBwQADgIHAgcEAA8CCQEHABAECgEHABMLDAEHAAULAQEIAAcJDQEIAAgKDgEIABwPEAEIABEPBwAAEg8HAQgBGAEYAQABHhAYAQACChMBAAIVHAwAAhcMEwACHxIMAAkQChULFQwVDRUEEAMUEQYQBg8VCxoMGgMHCAMJAAkBAAIGCAMJAAEGCQECBwgDCQABBwkBAQkBAQEBCwEBCQECBggDBQIHCAMFAgUJAAEFAQYJAAEHCQACBQUBCQADCwACCQAJAQUFAQYIAwEIAwIJAAkBAQsAAgkACQEDBQUJAQIJAAsBAQkBAQsBAQkABAYLAAIJAAgCBQYIAwYIAgELAAIJAAgCAgkACAIBBggCBAcLAAIJAAgCBQcIAwcIAgVGaWVsZAJJRAZPcHRpb24DVUlEA2FkZBBhZGRfY2hpbGRfb2JqZWN0BmJvcnJvdxNib3Jyb3dfY2hpbGRfb2JqZWN0F2JvcnJvd19jaGlsZF9vYmplY3RfbXV0CmJvcnJvd19tdXQGZGVsZXRlDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlCmZpZWxkX2luZm8OZmllbGRfaW5mb19tdXQQaGFzX2NoaWxkX29iamVjdBhoYXNfY2hpbGRfb2JqZWN0X3dpdGhfdHkRaGFzaF90eXBlX2FuZF9rZXkCaWQNaWRfdG9fYWRkcmVzcwRuYW1lEW5ld191aWRfZnJvbV9oYXNoBG5vbmUGb2JqZWN0Bm9wdGlvbgZyZW1vdmUTcmVtb3ZlX2NoaWxkX29iamVjdBByZW1vdmVfaWZfZXhpc3RzBHNvbWUOdWlkX3RvX2FkZHJlc3MFdmFsdWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAACAxQIAxYJACAJAQAUAAEAABEaCwAuERUMBQoFCgE4AAwECgUKBBEOIAQOBRAHACcLBBEUCwELAjkADAMLBQsDOAECAQEAAAwKCgARFQsBOAAMAgsACwI4AjcAAgIBAAAMCwoALhEVCwE4AAwCCwALAjgDNgACAwEAABYRCwAuERUMAwoDCwE4AAwCCwMLAjgEOgAMBAEREgsEAgQBAAAPCwsAERUMAwoDCwE4AAwCCwMLAhEOAgUBAAAXEwoACgEMAi4LAjgFBA0LAAsBOAY4BwwDBRELAAE4CAwDCwMCBgEAAA8LCwARFQwDCgMLATgADAILAwsCOAkCBwMAABkWCgARFQsBOAAMAwsACwM4CgwCCgI3AQwECgI3AgELAjcDDAULBAsFERMCCAMAAB0YCgAuERULATgADAMLAAsDOAsMAgoCNgEMBAoCNgIBCwI2AwwFCwQLBS4REwIJAwIACgMCAAsDAgAMAwIADQMCAA4DAgAPAwIAAAIAAAABABQBGwIbABsADAAOcHJpb3JpdHlfcXVldWXQCqEc6wsGAAAADQEABAIEDAMQPARMCgVWpwEH/QG4AQi1A0AG9QMOCoMEEguVBAQMmQTzBQ2MCgQOkAoEAAsBEAABBgECAAAABgECAAAGAAEBAgAIAgMBAgAEBAUBAgAHAwYBAgACBwABAgANCAUBAgAFCQUBAgAJCgsBAgEMDw0BAAEODw0BAAYNCQYFDQgQCA0BCgsBAQkAAQsAAQkAAQcLAAEJAAIDCQADBwsAAQkAAwkAAAELAQEJAAIKAwoJAAIHCgsBAQkAAwMHCgsBAQkAAwMBBgsAAQkAAQoDAgMDAQkAAwMDCQACBwoJAAMBAwUDAwMKCwEBCQAJAAUHCgsBAQkAAwcKCwEBCQADAw0HCgsBAQkAAQMHCgsBAQkAAwEHCgsBAQkAAwcKCwEBCQADAwMDAgMKAwVFbnRyeQ1Qcmlvcml0eVF1ZXVlDmNyZWF0ZV9lbnRyaWVzB2VudHJpZXMGaW5zZXJ0FW1heF9oZWFwaWZ5X3JlY3Vyc2l2ZQNuZXcJbmV3X2VudHJ5B3BvcF9tYXgKcHJpb3JpdGllcwhwcmlvcml0eQ5wcmlvcml0eV9xdWV1ZQZyZW1vdmUWcmVzdG9yZV9oZWFwX3JlY3Vyc2l2ZQtzd2FwX3JlbW92ZQV2YWx1ZQZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAoDAQAAAgEDCgsBAQkAAQICCgMPCQAADQENAAEAAAwYDgBBBgwCCgIGAgAAAAAAAAAaDAEKAQYAAAAAAAAAACQEFQUMCwEGAQAAAAAAAAAXDAENAAoCCgE4AAUHCwA5AAIBAQAADh4KADcAQQYMAQoBBgAAAAAAAAAAJAQJBQ0LAAEHACcKADYABgAAAAAAAAAAOAE6AQwDDAILADYACwEGAQAAAAAAAAAXBgAAAAAAAAAAOAALAgsDAgIBAAAQEQoANgALAQsCOQFEBgoANwBBBgYBAAAAAAAAABcMAwsANgALAzgCAgMBAAAFBAsACwE5AQIEAQAAESgOAEEQDAMOAUENCgMhBAkFCwYAAAAAAAAAACdABgAAAAAAAAAADAUGAAAAAAAAAAAMAgoCCgMjBCYFFA0ABgAAAAAAAAAAOAMMBA0BBgAAAAAAAAAAOAQMBg0FCwQLBjkBRAYLAgYBAAAAAAAAABYMAgUPCwUCBQAAABIuCgEGAAAAAAAAAAAhBAcLAAECCgEGAQAAAAAAAAAXBgIAAAAAAAAAGgwGCgAKAQwDDAIKAAoGDAUMBAsCLgsDQgY3ARQLBC4LBUIGNwEUJAQrCgALAQoGRwYLAAsGOAIFLQsAAQIGAAAAE24KAQYAAAAAAAAAACEEBwsAAQIKAgoBIwQMBRALAAEGAQAAAAAAAAAnCgIGAgAAAAAAAAAYBgEAAAAAAAAAFgwNCg0GAQAAAAAAAAAWDA8KAgwOCg0KASMENwoACg0MBQwDCgAKDgwHDAYLAy4LBUIGNwEUCwYuCwdCBjcBFCQMCAU5CQwICwgEPQsNDA4KDwoBIwRYCgAKDwwKDAkKAAoODAwMCwsJLgsKQgY3ARQLCy4LDEIGNwEUJAwEBVoJDAQLBAReCw8MDgoOCgIiBGsKAAoOCwJHBgsACwELDjgABW0LAAECBwEAABQcBwEMAgYAAAAAAAAAAAwBCgEKADcAQQYjBBgFCw0CCgA3AAoBQgY3ARREEAsBBgEAAAAAAAAAFgwBBQQLAAELAgIAAAEAAA0BDQAPdHJhbnNmZXJfcG9saWN5+xGhHOsLBgAAAA0BABgCGE4DZvMBBNkCKgWDA5YDB5kG5QQI/gpABr4LPAr6CzcLsQwKDLsM4QQNnBEQDqwREAA7AS8BPQATABUAHAAfAC4AMAA5ADwAQgAKAAEAAQAHDAEAAQAIDAEAAQAJAwEAAQAFBwECAQEDBwEAAAIMBwADAAQBAAEEAQwBAAEHAgcABw0EAAgEDAAJBgIACgsCAAsOBwEDAAAtAAEBAAAsAgMBAABDBAUBAAAZBgUBAAAWBwABAAARCAkDAAIGACUKCwMAAgYAEgwJAgACABANCQIAAgAmDg8CAAIANhAJAwACBgA+DhEBAAA/EBIBAAArExQBAAAxExUBAAAhExQBAAEaJBgBAAEqIw8BAAIkCRYBAANBJRUBAANECR8BAAQiKScBAAQzNQkBAAQ6JicBAAUPMQkCBwQFFDM0AgcEBSAzDwEHBTU3LwIHBAYdGAkBAwcYHAkAByciFAEIBywbHAAHQBEUAAgjGg8BAAsXLQ8BAwseCRcBAwsoMgkBAwspFysBAws4LBUBAyMWIRgcHRQeHiERFRAVEx4XHhUeJRYmFiIWCS4YMBIvJBYZMBYeGjYbMAMICQMICQELAAEJAAIGCAsHCA0CCwEBCQALAgEJAAQHCwEBCQAGCwIBCQALBQEDBwgNAQsIAQgMAwsBAQkACwIBCQAHCA0CBgsBAQkACwABCQAECQEHCwEBCQAGCwIBCQAJAgACCQEGCwEBCQABBgkCAwkBBwsBAQkACwgBCAwCCQEHCwABCQABBgsBAQkAAQECBwsBAQkABgsCAQkAAQYICgEHCAoBBgsAAQkAAQgJAQMBCAYBCw4BCQABCQAFCAoLDgEIBgsHAQgMCAoICQEGCAsBBwgNAQgKAQsDAQkAAQgMAQsHAQkAAwMDAwELAQEJAAEGCQABBgsFAQkAAQsFAQkAAQYLBwEJAAMHCwcBCQADBwgNAQsIAQkAAgsHAQgMCAoCCwcBCQAHCA0HCggGCAkICQMLDgEIBggGAwEKCQABBgsOAQkAAgYLDgEJAAYJAAIJAAkBAQkBAgsEAQkBCQIDBwgKCQAJAQIHCw4BCQAJAAIGCAoJAAEGCQECBwsHAQkACwgBCQABCwQBCQECBwgKCQAHQmFsYW5jZQRDb2luAklEBk9wdGlvbglQdWJsaXNoZXIHUnVsZUtleQNTVUkOVHJhbnNmZXJQb2xpY3kRVHJhbnNmZXJQb2xpY3lDYXAVVHJhbnNmZXJQb2xpY3lDcmVhdGVkD1RyYW5zZmVyUmVxdWVzdAlUeENvbnRleHQIVHlwZU5hbWUDVUlEBlZlY1NldANhZGQLYWRkX3JlY2VpcHQIYWRkX3J1bGUOYWRkX3RvX2JhbGFuY2UHYmFsYW5jZQZib3Jyb3cEY29pbg9jb25maXJtX3JlcXVlc3QIY29udGFpbnMGZGVsZXRlFGRlc3Ryb3lfYW5kX3dpdGhkcmF3DGRlc3Ryb3lfc29tZQtkdW1teV9maWVsZA1keW5hbWljX2ZpZWxkBGVtaXQFZW1wdHkFZXZlbnQHZXhpc3RzXwRmcm9tDGZyb21fYmFsYW5jZQxmcm9tX3BhY2thZ2UDZ2V0CGdldF9ydWxlCGhhc19ydWxlAmlkBmluc2VydAlpbnRvX2tleXMHaXNfc29tZQRpdGVtA25ldwtuZXdfcmVxdWVzdAZvYmplY3QGb3B0aW9uB3BhY2thZ2UEcGFpZAlwb2xpY3lfaWQDcHV0CHJlY2VpcHRzBnJlbW92ZQtyZW1vdmVfcnVsZQVydWxlcwRzaXplA3N1aQR0YWtlD3RyYW5zZmVyX3BvbGljeQp0eF9jb250ZXh0CXR5cGVfbmFtZQN1aWQQdWlkX211dF9hc19vd25lcgx1aWRfdG9faW5uZXIFdmFsdWUHdmVjX3NldAh3aXRoZHJhdwR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAACBCsICTEDIQgJNAsOAQgGAQIDJwgKEwsHAQgMNwsOAQgGAgICJwgKMggJAwIBJwgJBAIBGwEAGAMYARgCGAQvAAEAAAkGCwALAQsCOAA5AAIBAQAAGSALADgBBAQFCAsBAQYAAAAAAAAAACcKAREfDAUOBREgDAYKBjkBOAILBQwCOAAMAzgDDAQLAgsECwM5AgsBER8LBjkDAgIBAAAgMQoALjgECwE3ABQhBAkFDwsAAQsDAQcEJw4COAUEJQsCOAYMBgoGCgA3ATgHJQQcBSILAAELAwEHBScLBgwEBSkKADcBOAcMBAsEDAULADYBCwULAzgIAgMBAAAoGw4AOAQOATcAFCEECAUMCwIBBwQnCwE6AwEMBAsAOgIBDAMRHQsEER0LAwsCOAkCBAEAACo0CwE6AAwGDAMMBQwECwY4CgwCDgJBFgwICggKADcCOAshBBMFFwsAAQcAJwoIBgAAAAAAAAAAJAQuBRwNAkUWDAcKADcCDgc4DAQlBSkLAAEHAScLCAYBAAAAAAAAABcMCAUXCwABCwQLBQsDAgUBAAAJIgoBLjgECwI3ABQhBAkFDQsBAQcEJwoBLjgNIAQTBRcLAQEHAycKATYDCTkECwM4DgsBNgI4DzgQAgYBAAAJBgsBNwMJOQQ4EQIHAQAACQ4KAS44DQQFBQkLAQEHAicLATYBCwI4EgIIAQAACQULATYEOA84EAIJAQAACQYLADcDCTkEOBMCCgEAAAkUCgAuOAQLATcAFCEECQUNCwABBwQnCwA2Awk5BDgUAQILAQAACQMLADcDAgwBAAAJEAoALjgECwE3ABQhBAkFDQsAAQcEJwsANgMCDQEAAAkECwA3BRQCDgEAAAkECwA3BhQCDwEAAAkECwA3BxQCAgEBAQECAQAAAwAAAAEAAgAYARgCGAMYBBgFGAYYBxgAFGR5bmFtaWNfb2JqZWN0X2ZpZWxk2QehHOsLBgAAAAoBAAgCCBQDHIoBBKYBGgXAAYMBB8MCsgII9QRACrUFBgu7BQIMvQXpAQALARYACgAVAAMHAQAAAQEHAQAAAwAHAAMCBAAABAABAgcMAAYCAwIHDAAJBAUCBwwAFwQGAgcMAAwCBwEHAA0CBwIHDAARAggBBwEUARgBAAEZChgBAAIEAAECBwQCBRIBAQgCBw8LAQgCCBMUAQgCDQIHAgcEAg4CDwEHAg8EEwEHAhAWBwEIAhcEBgIHBAIYFgoBCAMRCwwBCAMSEQwAAxoQEQATBgkNDg4KBgsGDw4MBhIGEQ0NDRAGBwwIDAMHCAMJAAkBAAIGCAMJAAEGCQECBwgDCQABBwkBAQkBAQEBCwEBCAIDCwABCQAIAgsAAQkAAQkAAQYJAAEIAgILAAEJAAgCAQsAAQkAAgYIAwUBBggDAQUCBQkAAgcIAwUBBwkABAsAAQkACwABCQAJAQUCBQUCCwABCQAFAQsBAQkAAklEBk9wdGlvbgNVSUQHV3JhcHBlcgNhZGQQYWRkX2NoaWxkX29iamVjdAZib3Jyb3cTYm9ycm93X2NoaWxkX29iamVjdBdib3Jyb3dfY2hpbGRfb2JqZWN0X211dApib3Jyb3dfbXV0DWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlCmZpZWxkX2luZm8OZmllbGRfaW5mb19tdXQYaGFzX2NoaWxkX29iamVjdF93aXRoX3R5AmlkD2lkX2Zyb21fYWRkcmVzcwRuYW1lBG5vbmUGb2JqZWN0Bm9wdGlvbgZyZW1vdmUTcmVtb3ZlX2NoaWxkX29iamVjdARzb21lDnVpZF90b19hZGRyZXNzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQACARMJAAAKAAEAAAkVCwE5AAwFDgI4AAwECgAKBQsEOAELAAsFDAMuCwM4AgERFQsCOAMCAQEAAA4ICwE5AAwCCwALAjgCOAQCAgEAAA4ICwE5AAwCCwALAjgFOAYCAwEAABUUCwE5AAwDCgAKAwwCLgsCOAIMBREVCwU4BwwECwALAzgIAQsEAgQBAAAOBwsBOQAMAgsACwI4CQIFAQAAFxQLATkADAIKAAoCOAkgBAwLAAEJAgsACwI4AgwDERULAzgKAgYBAAAXFQsBOQAMAgoACgI4CSAEDAsAATgLAgsACwI4AgwDAQsDERQ4DAIANwp0eF9jb250ZXh0CVR4Q29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdAJJRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdANVSUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDYmFnA0JhZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2JhbGFuY2UGU3VwcGx5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHYmFsYW5jZQdCYWxhbmNlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDYmNzA0JDUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBmJvcnJvdwhSZWZlcmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBmJvcnJvdwZCb3Jyb3cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVjbG9jawVDbG9jawAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3VybANVcmwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luBENvaW4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luDENvaW5NZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBGNvaW4LVHJlYXN1cnlDYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luD0N1cnJlbmN5Q3JlYXRlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3ZlY19tYXAGVmVjTWFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHdmVjX21hcAVFbnRyeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3BhY2thZ2UJUHVibGlzaGVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQpVcGdyYWRlQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQ1VcGdyYWRlVGlja2V0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQ5VcGdyYWRlUmVjZWlwdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2Rpc3BsYXkHRGlzcGxheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2Rpc3BsYXkORGlzcGxheUNyZWF0ZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdkaXNwbGF5DlZlcnNpb25VcGRhdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIUZHluYW1pY19vYmplY3RfZmllbGQHV3JhcHBlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2dyb3RoMTYFQ3VydmUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdncm90aDE2FFByZXBhcmVkVmVyaWZ5aW5nS2V5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHZ3JvdGgxNhFQdWJsaWNQcm9vZklucHV0cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2dyb3RoMTYLUHJvb2ZQb2ludHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgd2ZWNfc2V0BlZlY1NldAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3N1aQNTVUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg90cmFuc2Zlcl9wb2xpY3kPVHJhbnNmZXJSZXF1ZXN0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5DlRyYW5zZmVyUG9saWN5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5EVRyYW5zZmVyUG9saWN5Q2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5FVRyYW5zZmVyUG9saWN5Q3JlYXRlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD3RyYW5zZmVyX3BvbGljeQdSdWxlS2V5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sFS2lvc2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zaw1LaW9za093bmVyQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sLUHVyY2hhc2VDYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawZCb3Jyb3cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawRJdGVtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sHTGlzdGluZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBWtpb3NrBExvY2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawpJdGVtTGlzdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMbGlua2VkX3RhYmxlC0xpbmtlZFRhYmxlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMbGlua2VkX3RhYmxlBE5vZGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgpvYmplY3RfYmFnCU9iamVjdEJhZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDG9iamVjdF90YWJsZQtPYmplY3RUYWJsZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDnByaW9yaXR5X3F1ZXVlDVByaW9yaXR5UXVldWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg5wcmlvcml0eV9xdWV1ZQVFbnRyeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBXRhYmxlBVRhYmxlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJdGFibGVfdmVjCFRhYmxlVmVjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJdmVyc2lvbmVkCVZlcnNpb25lZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCXZlcnNpb25lZBBWZXJzaW9uQ2hhbmdlQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAAAAAAAAAwABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBAAAAAAAAAAsHZ2VuZXNpc4AToRzrCwYAAAALAQAaAho6A1RrBL8BDgXNAbACB/0DiQkIhg1gBuYNFAr6DV0M1w7bAw2yEhgAHwEsAUgCEgIUAisCPQJCADYAPwBAAEMARgADAwAAAgMAAAkAAAAIAAABBAcBAAADAAQBAAEEAQwBAAEFCwQABgUCAAcKAgAIBgQACgcEAAsMBAAAFgABAAAPAgEAAA4DAQABGRkaAQABJBgOAQACIxYOAQADGgkBAQADNQgJAQADSwEJAQAEHR4fAQAGQSABAAcbBQYACBYREgAJFhMBAAoXDxAACw0iAQALKgwKAAs0HQEADCAbHAAMIg0OAAcHCAcFFQQXAxcJBwYHBggHCwUBCAgIAQoIAAgCBwgJAAQLBQEICAoIAwcKCAwHCAkBBwoIDBkKCAMDAwoCAwMKAgoCCgIKAgoCCgIKAgoCCgIICgMLBQEICAsFAQgIBQgLCAwKCAwKAgoCAQYICQEDAQgIAgcLBQEJAAMBCwUBCQABCAwBCAAQBQoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgJAgYKCAwGCAwBAQgDAwMDAwMDBwgJAQgLBQsFAQgIAwMNBwgJAQgKCAgHCggMCwUBCAgDAwgLCAoHCAkFCwUBCAgDBQsEAQUFAQgDAQYKCQABBQEGCwQBCQABCwQBCQABCQACBwoIDAUBBwgMBAcIDAsFAQgIBQcICQILBQEJAAcICQELBgEJAAILBgEICAUCAwMCBwgMAwdCYWxhbmNlBENvaW4WR2VuZXNpc0NoYWluUGFyYW1ldGVycxhHZW5lc2lzVmFsaWRhdG9yTWV0YWRhdGEGT3B0aW9uA1NVSQxTdGFrZVN1YnNpZHkQU3lzdGVtUGFyYW1ldGVycw9Ub2tlbkFsbG9jYXRpb24ZVG9rZW5EaXN0cmlidXRpb25TY2hlZHVsZQlUeENvbnRleHQDVUlECVZhbGlkYXRvcghhY3RpdmF0ZRNhY3RpdmF0ZV92YWxpZGF0b3JzD2FsbG9jYXRlX3Rva2VucwthbGxvY2F0aW9ucwthbW91bnRfbWlzdAdiYWxhbmNlGGNoYWluX3N0YXJ0X3RpbWVzdGFtcF9tcwRjb2luD2NvbW1pc3Npb25fcmF0ZQZjcmVhdGUYY3JlYXRlX3N5c3RlbV9wYXJhbWV0ZXJzC2Rlc2NyaXB0aW9uDGRlc3Ryb3lfc29tZQxkZXN0cm95X3plcm8FZXBvY2gRZXBvY2hfZHVyYXRpb25fbXMMZnJvbV9iYWxhbmNlCWdhc19wcmljZQdnZW5lc2lzEWdldF92YWxpZGF0b3JfbXV0CWltYWdlX3VybBZpc19kdXBsaWNhdGVfdmFsaWRhdG9yCGlzX2VtcHR5B2lzX3NvbWUTbWF4X3ZhbGlkYXRvcl9jb3VudBttaW5fdmFsaWRhdG9yX2pvaW5pbmdfc3Rha2UEbmFtZQ9uZXR3b3JrX2FkZHJlc3MSbmV0d29ya19wdWJsaWNfa2V5A25ldwZvYmplY3QGb3B0aW9uC3AycF9hZGRyZXNzD3ByaW1hcnlfYWRkcmVzcwtwcm9qZWN0X3VybBNwcm9vZl9vZl9wb3NzZXNzaW9uE3Byb3RvY29sX3B1YmxpY19rZXkQcHJvdG9jb2xfdmVyc2lvbhFyZWNpcGllbnRfYWRkcmVzcxxyZXF1ZXN0X2FkZF9zdGFrZV9hdF9nZW5lc2lzBXNwbGl0DXN0YWtlX3N1YnNpZHkbc3Rha2Vfc3Vic2lkeV9kZWNyZWFzZV9yYXRlF3N0YWtlX3N1YnNpZHlfZnVuZF9taXN0KXN0YWtlX3N1YnNpZHlfaW5pdGlhbF9kaXN0cmlidXRpb25fYW1vdW50G3N0YWtlX3N1YnNpZHlfcGVyaW9kX2xlbmd0aBlzdGFrZV9zdWJzaWR5X3N0YXJ0X2Vwb2NoFXN0YWtlZF93aXRoX3ZhbGlkYXRvcgNzdWkLc3VpX2FkZHJlc3MKc3VpX3N5c3RlbRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyCHRyYW5zZmVyCnR4X2NvbnRleHQJdmFsaWRhdG9yIHZhbGlkYXRvcl9sb3dfc3Rha2VfZ3JhY2VfcGVyaW9kHXZhbGlkYXRvcl9sb3dfc3Rha2VfdGhyZXNob2xkDXZhbGlkYXRvcl9zZXQidmFsaWRhdG9yX3ZlcnlfbG93X3N0YWtlX3RocmVzaG9sZAZ2ZWN0b3IOd29ya2VyX2FkZHJlc3MRd29ya2VyX3B1YmxpY19rZXkEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAAIPJwoCGAoCIQoCLwoCPgUeAxUDMQoCMAoCKQoCSgoCKAoCLQoCLgoCSQoCAQIMMgMTAxwDOwM5AzoDNw0lAyYDRQNHA0QDAgICOAMQCggDAwIDMwURAzwLBAEFAAAAAASTAQoFLhELBgAAAAAAAAAAIQQHBQsLBQEHACcLBBMCDAYMFg0BCxY4AAwYOAEMF0AKAAAAAAAAAAAMHA4DQQsMCAYAAAAAAAAAAAwLCgsKCCMEWQUhDgMKC0ILFBMADB0MEQwQDA4MHgwPDBMMFAwHDAoMGQwSDAwMCQwNCxkLFAsPCx4LEwsNCwkLDAsSCw4LEAsRCx0LCgsHCgUREAwbDhwOGxETIARNBVELBQEHAScNHAsbRAoLCwYBAAAAAAAAABYMCwUcCwELBg0cCgURAQ0cEQIOAhAAFA4CEAEUDgIQAhQOAhADFA4CEAQUDgIQBRQOAhAGFAoFEQ4MGgsYDgIQBxQOAhAIFA4CEAkUCgURDAwVCwALHAsXDgIQChQOAhALFAsaCxULBRENAgEAAAAULA4BOAIgBCMFBQ0BRRUTAwwHDAUMBg0ACwU4AAwEDgc4AwQdCwc4BAwICgILCBESCwQLBgoDEREFIgsECgM4BQsGEQoFAAsCAQsDAQsBRhUAAAAAAAAAAAsAOAYCAgAAACEYCgAuQQoMAQYAAAAAAAAAAAwCCgIKASMEFQULCgAKAkMKBgAAAAAAAAAAEQ8LAgYBAAAAAAAAABYMAgUGCwABAgECAQMBBwEIAQkBCgELAQQBBQEGAQABAQAJdmFsaWRhdG9y0jyhHOsLBgAAAAwBAB8CH0gDZ7cEBJ4FJgXEBfADB7QJyRMI/RxgBt0dqgEKhx+cAQyjIKkbDcw7PA+IPA0AhgEBFAEXAUkBZwIVAhYCIgJHAmgCbwKDAQBlAIgBAA4EAAANBAAACAMAAAsDAAEJBwADAwcBAAAECQcABQAMAAYBBAEAAQgCBwAJBQIACgoCAAsMBwAMBAcADAYIAAwHDAANDwIAADcAAQAANQIDAAAaBAUAABAEBQAAEgYFAABWBwUAAFcHBQAAWggFAABZCQUAAF4JBQAAWAQFAABdBAUAAB0KBQAAUgsFAAAuDA0AADAMDgAAaQwPAAAxDBAAAB4MEAAAKQwRAABTDBEAADMMEAAASgwQAABPDBAAAI4BDBAAAFUMEgAAVAwSAAA0DBIAAI8BDBIAAD0MEwAAPwwTAABADBMAAEQMEwAAQgwUAABBDBQAAD4MFAAARQwUAABIDBUAADsMFgAAbgwWAABiDBYAAG0MFgAAjQEMFgAAXwQFAABLDBYAAEwMFgAAJgwWAAAZDBYAAE4XGAAAZgwZAAAqGg0AACwbDQEAACscDQEAADkLBQAAeh0FAAB4HQUAAHkdBQAAggEdBQAAex0FAABxHQUAAH0dBQAAcx0FAAB+HQUAAHQdBQAAgAEdBQAAdh0FAAB/HgUAAHUeBQAAfB0FAAByHQUAAIEBHQUAAHcdBQAAHwYFAACEAQ4FAACFAR8FAAA2IAMAAWcfJgACbD4fAQADGEA+AQADJEMzAQADLUANAQADL0ANAQADRgUiAQADYDMiAQAEJSYjAAU1KCkABosBLRYBAAcgMwUBAwgoPhkBCAohLhYAClwuDwALOB8nAAwRKgUADBsqBQAMHDoFAAwuMA0ADDUoPQAMSzAWAAxMMBYADE48GAAMUTEFAAxSOwUADFYvBQAMWjYWAAxhNRYADGM1FgAMajAWAA05QhkADYwBODkAUh9SI1YsVzJXN1g9NCM0HzMjMx9QM04zUyNTH1EjTyNRH08fTQEOBQoCCgIKAgoCCAYIBggMCAwIBggGCAYIBggHAQgAEAUKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIDAwcICwEIAQIHCAEDAAEHCAEEBwgBCwgBCAoFBwgLAwcIAQgOBwgLAwcIAQgQAwIHCAELCAEICgIHCAEHCAsBBggBAQEBBggAAQUBBggGAQYIDAEGCgIBBgsFAQgGAQYLBQEKAgEGCAkBAwIGCAEDAQgNAQgJAgYIAQYIAQIGCwUBCQAGCQACBgsFAQkABgsFAQkAAgcIAQoCAwcIAQoCCgIBCgIECAADAwcICxYFCAYIBggGCAYLBQEKAgsFAQoCCwUBCgILBQEKAgsFAQgGCwUBCAYKAgsFAQgGCwUBCAYIBwoCCgIKAggGCAYIDAgMAQsFAQkAAQgGCAEBAQEBAQEIAAECAQgEAQgMAQcICwEIBwIHCA8DAgMDAQgKAQYLCAEJAAEGCAsFBwgPCwgBCAoFAwcICwEGCA8BBwgPAQgCAQkABAMDAwMBBggOAwcIDwgOBwgLAQgDAQYIEAEGBQIHCA8LCAEICgIHCA8HCAsCBggPAwEIDwEGCQAdAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBBgsFAQkAAgEBAgUHCAsBBwsFAQkAAwgJCA8FA0JhZwdCYWxhbmNlAklEBk9wdGlvbhVQb29sVG9rZW5FeGNoYW5nZVJhdGUDU1VJCVN0YWtlZFN1aQtTdGFraW5nUG9vbBNTdGFraW5nUmVxdWVzdEV2ZW50BlN0cmluZwlUeENvbnRleHQVVW5zdGFraW5nUmVxdWVzdEV2ZW50A1VybAlWYWxpZGF0b3IRVmFsaWRhdG9yTWV0YWRhdGEVVmFsaWRhdG9yT3BlcmF0aW9uQ2FwCGFjdGl2YXRlFWFjdGl2YXRlX3N0YWtpbmdfcG9vbBphZGp1c3Rfc3Rha2VfYW5kX2dhc19wcmljZQZhbW91bnQFYXNjaWkDYmFnB2JhbGFuY2UDYmNzBmJvcnJvdw9jb21taXNzaW9uX3JhdGUKZGVhY3RpdmF0ZRdkZWFjdGl2YXRlX3N0YWtpbmdfcG9vbA9kZXBvc2l0X3Jld2FyZHMVZGVwb3NpdF9zdGFrZV9yZXdhcmRzC2Rlc2NyaXB0aW9uGmVmZmVjdHVhdGVfc3RhZ2VkX21ldGFkYXRhBGVtaXQFZXBvY2gFZXZlbnQMZXh0cmFfZmllbGRzB2V4dHJhY3QKZnJvbV9hc2NpaQlnYXNfcHJpY2UHZ2VuZXNpcwJpZAlpbWFnZV91cmwMaXNfZHVwbGljYXRlDWlzX2VxdWFsX3NvbWUXaXNfZXF1YWxfc29tZV9hbmRfdmFsdWUHaXNfbm9uZQxpc19wcmVhY3RpdmUHaXNfc29tZQhtZXRhZGF0YQRuYW1lC25ldF9hZGRyZXNzD25ldHdvcmtfYWRkcmVzcxRuZXR3b3JrX3B1YmtleV9ieXRlcwNuZXcRbmV3X2Zyb21fbWV0YWRhdGEMbmV3X21ldGFkYXRhFW5ld191bnNhZmVfZnJvbV9ieXRlczNuZXdfdW52ZXJpZmllZF92YWxpZGF0b3Jfb3BlcmF0aW9uX2NhcF9hbmRfdHJhbnNmZXIabmV4dF9lcG9jaF9jb21taXNzaW9uX3JhdGUUbmV4dF9lcG9jaF9nYXNfcHJpY2UWbmV4dF9lcG9jaF9uZXRfYWRkcmVzcxpuZXh0X2Vwb2NoX25ldHdvcmtfYWRkcmVzcx9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5X2J5dGVzFm5leHRfZXBvY2hfcDJwX2FkZHJlc3MabmV4dF9lcG9jaF9wcmltYXJ5X2FkZHJlc3MebmV4dF9lcG9jaF9wcm9vZl9vZl9wb3NzZXNzaW9uIG5leHRfZXBvY2hfcHJvdG9jb2xfcHVia2V5X2J5dGVzEG5leHRfZXBvY2hfc3Rha2UZbmV4dF9lcG9jaF93b3JrZXJfYWRkcmVzcx5uZXh0X2Vwb2NoX3dvcmtlcl9wdWJrZXlfYnl0ZXMEbm9uZQZvYmplY3QQb3BlcmF0aW9uX2NhcF9pZAZvcHRpb24LcDJwX2FkZHJlc3MUcGVuZGluZ19zdGFrZV9hbW91bnQdcGVuZGluZ19zdGFrZV93aXRoZHJhd19hbW91bnQHcG9vbF9pZCFwb29sX3Rva2VuX2V4Y2hhbmdlX3JhdGVfYXRfZXBvY2gPcHJpbWFyeV9hZGRyZXNzEHByaW5jaXBhbF9hbW91bnQVcHJvY2Vzc19wZW5kaW5nX3N0YWtlJHByb2Nlc3NfcGVuZGluZ19zdGFrZXNfYW5kX3dpdGhkcmF3cwtwcm9qZWN0X3VybBNwcm9vZl9vZl9wb3NzZXNzaW9uFXByb3RvY29sX3B1YmtleV9ieXRlcxFyZXF1ZXN0X2FkZF9zdGFrZRxyZXF1ZXN0X2FkZF9zdGFrZV9hdF9nZW5lc2lzG3JlcXVlc3Rfc2V0X2NvbW1pc3Npb25fcmF0ZRVyZXF1ZXN0X3NldF9nYXNfcHJpY2UWcmVxdWVzdF93aXRoZHJhd19zdGFrZQ1yZXdhcmRfYW1vdW50BnNlbmRlch1zZXRfY2FuZGlkYXRlX2NvbW1pc3Npb25fcmF0ZRdzZXRfY2FuZGlkYXRlX2dhc19wcmljZRBzZXRfdm90aW5nX3Bvd2VyBHNvbWUWc3Rha2VfYWN0aXZhdGlvbl9lcG9jaAxzdGFrZV9hbW91bnQRc3Rha2VkX3N1aV9hbW91bnQOc3Rha2VyX2FkZHJlc3MMc3Rha2luZ19wb29sD3N0YWtpbmdfcG9vbF9pZAZzdHJpbmcDc3VpC3N1aV9hZGRyZXNzC3N1aV9iYWxhbmNlFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIIdG9fYnl0ZXMLdG90YWxfc3Rha2USdG90YWxfc3Rha2VfYW1vdW50CnR4X2NvbnRleHQPdW5zdGFraW5nX2Vwb2NoIHVwZGF0ZV9jYW5kaWRhdGVfbmV0d29ya19hZGRyZXNzH3VwZGF0ZV9jYW5kaWRhdGVfbmV0d29ya19wdWJrZXkcdXBkYXRlX2NhbmRpZGF0ZV9wMnBfYWRkcmVzcyB1cGRhdGVfY2FuZGlkYXRlX3ByaW1hcnlfYWRkcmVzcyB1cGRhdGVfY2FuZGlkYXRlX3Byb3RvY29sX3B1YmtleR91cGRhdGVfY2FuZGlkYXRlX3dvcmtlcl9hZGRyZXNzHnVwZGF0ZV9jYW5kaWRhdGVfd29ya2VyX3B1YmtleRJ1cGRhdGVfZGVzY3JpcHRpb24QdXBkYXRlX2ltYWdlX3VybAt1cGRhdGVfbmFtZSF1cGRhdGVfbmV4dF9lcG9jaF9uZXR3b3JrX2FkZHJlc3MgdXBkYXRlX25leHRfZXBvY2hfbmV0d29ya19wdWJrZXkddXBkYXRlX25leHRfZXBvY2hfcDJwX2FkZHJlc3MhdXBkYXRlX25leHRfZXBvY2hfcHJpbWFyeV9hZGRyZXNzIXVwZGF0ZV9uZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleSB1cGRhdGVfbmV4dF9lcG9jaF93b3JrZXJfYWRkcmVzcx91cGRhdGVfbmV4dF9lcG9jaF93b3JrZXJfcHVia2V5EnVwZGF0ZV9wcm9qZWN0X3VybAN1cmwRdmFsaWRhdGVfbWV0YWRhdGEVdmFsaWRhdGVfbWV0YWRhdGFfYmNzCXZhbGlkYXRvchF2YWxpZGF0b3JfYWRkcmVzcw12YWxpZGF0b3JfY2FwDXZhbGlkYXRvcl9zZXQRdmFsaWRhdG9yX3dyYXBwZXIFdmFsdWUedmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzDHZvdGluZ19wb3dlcg53b3JrZXJfYWRkcmVzcxN3b3JrZXJfcHVia2V5X2J5dGVzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMICgAAAAAAAAADCAsAAAAAAAAAAwgMAAAAAAAAAAMIZAAAAAAAAAADCGUAAAAAAAAAAwgQJwAAAAAAAAMIAAEAAAAAAAAAAhZpBVUKAjQKAo8BCgJUCgIxCAYeCAYpCAxTCAwyCAZKCAZPCAaOAQgGQgsFAQoCQQsFAQoCPgsFAQoCRQsFAQoCPAsFAQgGPwsFAQgGQAsFAQgGRAsFAQgGIwgHAQIKMAgAjQEDSAgJJgNlCA8ZA0MDOwM6AyMIBwICBU0ICYcBBWQFIQMTAwMCB00ICYcBBWQFYQNwA1ADWwMAAwAAIUQLAAwOCwEMGQsCDB0LAwweCwQMHwsFDCALBgwhCwcMIgsIDCMLCQwPCwoMEAsLDBELDAwSOAAMEzgADBQ4AAwVOAAMFjgBDBc4AQwYOAEMGjgBDBsLDQwcCw4LGQsdCx4LHwsgCyELIgsjCw8LEAsRCxILEwsWCxQLFQsXCxgLGgsbCxwSAAIBAwAAJIABDglBJQcQJQQLDgpBJQcQJQwQBQ0JDBALEAQVDgtBJQcQJQwRBRcJDBELEQQfDgxBJQcQJQwSBSEJDBILEgQpDgVBJQcQJQwTBSsJDBMLEwQzDgZBJQcQJQwUBTUJDBQLFAQ9DgdBJQcQJQwVBT8JDBULFQRHDghBJQcQJQwWBUkJDBYLFgRMBVALDwEHCScKDgcPJQRVBVkLDwEHCCcLAAsBCwILAwsECwURTBFUCwYRTBFUCwcRWwsIEVsLCRFMEVQLChFMEVQLCxFMEVQLDBFMEVQKDxFVEQAMFw4XEUkLFwsNCw4LDxFLAgIDAAAFBQsADwALARFdAgMDAAAFBQsADwALARFcAgQDAAAFDQoAEAEUCgAPAhUKABADFAsADwQVAgUDAAArOQ4BOAIMBAoEBgAAAAAAAAAAJAQIBQ4LAAELAwEHCycKAy4RWQYBAAAAAAAAABYMBQoADwALAQoCCwUKAxFmCgAQABFfBCIKAA8AEWQKABAFFAoEFgoADwUVCgAuETELABAGEAcUCwILAy4RWQsEEgI4AwIGAwAAFi4KAy4RWQYAAAAAAAAAACEEBwUNCwABCwMBBwwnDgE4AgwECgQGAAAAAAAAAAAkBBUFGwsAAQsDAQcLJwoADwALAQsCBgAAAAAAAAAACwMRZgoADwARZAoAEAUUCwQWCwAPBRUCBwMAADQrDgERaQwDDgERaAwFCgAPAAsBCgIRZwwGCgYKAxcMBAoAEAUUCwYXCgAPBRUKAC4RMQsAEAYQBxQKAi4RWgsFCwIuEVkLAwsEEgM4BAIIAwAABRMOARFsFAoAEAYQBxQhBAoFDgsAAQcOJwsCCwAPARUCCQMAAAUgCgAuEQ4EBQUJCwABBwonDgERbBQKABAGEAcUIQQTBRcLAAEHDicKAgoADwEVCwILAA8CFQIKAwAABQ4KAQcPJQQFBQkLAAEHCCcLAQsADwMVAgsDAAAFFwoALhEOBAUFCQsAAQcKJwoBBw8lBA4FEgsAAQcIJwsBCwAPBBUCDAMAAAUOCgAQBRQOATgCFgoADwUVCwAPAAsBEV4CDQMAAAUQCgAPAAsBEWUKAC4RKAsAEAUUIQQNBQ8HCycCDgEAAAUECwAQABFfAg8BAAAFAwsAEAYCEAEAAAUFCwAQBhAHFAIRAQAABQQLABAGEAgCEgEAAAUECwAQBhAJAhMBAAAFBAsAEAYQCgIUAQAABQQLABAGEAsCFQEAAAUECwAQBhAMAhYBAAAFBAsAEAYQDQIXAQAABQQLABAGEA4CGAEAAAUECwAQBhAPAhkBAAAFBAsAEAYQEAIaAQAABQQLABAGEBECGwEAAAUECwAQBhASAhwBAAAFBAsAEAYQEwIdAQAABQQLABAGEBQCHgEAAAUECwAQBhAVAh8BAAAFBAsAEAYQFgIgAQAABQQLABAGEBcCIQEAAAUECwAQBhAYAiIBAAAFBAsAEAYQGQIjAQAABQQLABAGEBoCJAEAAAUECwAQBhAbAiUBAAAFAwsAEBwCJgEAAAUECwAQARQCJwEAAAUFKAsAEAARagIoAQAABQQLABAAEWoCKQEAAAUDCwARKAIqAQAABQQLABAdFAIrAwAABQULAQsADx0VAiwBAAAFBAsAEAARYQItAQAABQQLABAAEWICLgEAAAUECwAQAhQCLwEAAAUECwAQBBQCMAEAAAUFCwAQAAsBEWMCMQEAAAUECwAQADgFAjIBAAA/lwMKABAGEAcUCgEQBhAHFCEEDQgMAgUXCgAQBhAIFAoBEAYQCBQhDAILAgQcCAwNBSYKABAGEAwUCgEQBhAMFCEMDQsNBCsIDBgFNQoAEAYQDRQKARAGEA0UIQwYCxgEOggMGQVECgAQBhAQFAoBEAYQEBQhDBkLGQRJCAwaBVMKABAGEBIUCgEQBhASFCEMGgsaBFgIDBsFYgoAEAYQEhQKARAGEBMUIQwbCxsEZwgMHAVxCgAQBhATFAoBEAYQExQhDBwLHAR2CAwdBYABCgAQBhATFAoBEAYQEhQhDB0LHQSFAQgMHgWNAQoAEAYQFAoBEAYQFDgGDB4LHgSSAQgMAwWaAQoAEAYQFQoBEAYQFTgGDAMLAwSfAQgMBAWnAQoAEAYQGAoBEAYQGDgHDAQLBASsAQgMBQW0AQoAEAYQGgoBEAYQGjgHDAULBQS5AQgMBgXBAQoAEAYQGgoBEAYQGzgHDAYLBgTGAQgMBwXOAQoAEAYQGwoBEAYQGzgHDAcLBwTTAQgMCAXbAQoAEAYQGwoBEAYQGjgHDAgLCATgAQgMCQXoAQoAEAYQFAoBEAYQDDgIDAkLCQTtAQgMCgX1AQoAEAYQFQoBEAYQDTgIDAoLCgT6AQgMCwWCAgoAEAYQGAoBEAYQEDgJDAsLCwSHAggMDAWPAgoAEAYQGgoBEAYQEjgJDAwLDASUAggMDgWcAgoAEAYQGgoBEAYQEzgJDA4LDgShAggMDwWpAgoAEAYQGwoBEAYQEzgJDA8LDwSuAggMEAW2AgoAEAYQGwoBEAYQEjgJDBALEAS7AggMEQXDAgoBEAYQFAoAEAYQDDgIDBELEQTIAggMEgXQAgoBEAYQFQoAEAYQDTgIDBILEgTVAggMEwXdAgoBEAYQGAoAEAYQEDgJDBMLEwTiAggMFAXqAgoBEAYQGgoAEAYQEjgJDBQLFATvAggMFQX3AgoBEAYQGgoAEAYQEzgJDBULFQT8AggMFgWEAwoBEAYQGwoAEAYQEzgJDBYLFgSNAwsAAQsBAQgMFwWVAwsBEAYQGwsAEAYQEjgJDBcLFwIzAAAADREKADgKBAoLAQELAAEJDAIFDwsAOAsLASEMAgsCAjQAAABBGgoAOAoEBggMAgUJCgE4CgwCCwIEEgsBAQsAAQkMAwUYCwA4CwsBOAshDAMLAwI1AwAADxkKAS4RWgwCCgIKABAGEAcUIQQMBRILAAELAQEHDScLAgsBEWsLAA8cFQI2AwAABRIOAUElBxAlBAYFCgsAAQcJJwsBEUwRVAsADwYPCBUCNwMAAAUSDgFBJQcQJQQGBQoLAAEHCScLARFMEVQLAA8GDwkVAjgDAAAFEQ4BQSUHECUEBgUKCwABBwknCwERWwsADwYPChUCOQMAAAURDgFBJQcQJQQGBQoLAAEHCScLARFbCwAPBg8LFQI6AwAABRYOAUElBxAlBAYFCgsAAQcJJwsBEUwRVDgMCgAPBg8UFQsAEAYRSQI7AwAABR4KAC4RDgQFBQkLAAEHCicOAUElBxAlBA8FEwsAAQcJJwsBEUwRVAoADwYPDBULABAGEUkCPAMAAAUWDgFBJQcQJQQGBQoLAAEHCScLARFMEVQ4DAoADwYPFRULABAGEUkCPQMAAAUeCgAuEQ4EBQUJCwABBwonDgFBJQcQJQQPBRMLAAEHCScLARFMEVQKAA8GDw0VCwAQBhFJAj4DAAAFFg4BQSUHECUEBgUKCwABBwknCwERTBFUOAwKAA8GDxYVCwAQBhFJAj8DAAAFHgoALhEOBAUFCQsAAQcKJw4BQSUHECUEDwUTCwABBwknCwERTBFUCgAPBg8OFQsAEAYRSQJAAwAABRYOAUElBxAlBAYFCgsAAQcJJwsBEUwRVDgMCgAPBg8XFQsAEAYRSQJBAwAABR4KAC4RDgQFBQkLAAEHCicOAUElBxAlBA8FEwsAAQcJJwsBEUwRVAoADwYPDxULABAGEUkCQgMAAAUQCwE4DQoADwYPGBULAjgNCgAPBg8ZFQsAEAYRSQJDAwAABRcKAC4RDgQFBQkLAAEHCicLAQoADwYPEBULAgoADwYPERULABAGEUkCRAMAAAUKCwE4DQoADwYPGhULABAGEUkCRQMAAAUSCgAuEQ4EBQUJCwABBwonCwEKAA8GDxIVCwAQBhFJAkYDAAAFCgsBOA0KAA8GDxsVCwAQBhFJAkcDAAAFEgoALhEOBAUFCQsAAQcKJwsBCgAPBg8TFQsAEAYRSQJIAwAABY8BCgAuER04DgQSCgAPBg8UOA8KAA8GDwwVOAEKAA8GDxQVCgAuER44DgQkCgAPBg8VOA8KAA8GDw0VOAEKAA8GDxUVCgAuER84DgQ2CgAPBg8WOA8KAA8GDw4VOAEKAA8GDxYVCgAuESA4DgRICgAPBg8XOA8KAA8GDw8VOAEKAA8GDxcVCgAuESE4EARnCgAPBg8YOBEKAA8GDxAVOAAKAA8GDxgVCgAPBg8ZOBEKAA8GDxEVOAAKAA8GDxkVCgAuESM4EAR5CgAPBg8aOBEKAA8GDxIVOAAKAA8GDxoVCgAuESQ4EASMAQoADwYPGzgRCgAPBg8TFTgACwAPBg8bFQWOAQsAAQJJAQAABQQLADgSEUoCSgECAEsAAABEGA4AEAcUDAYKAxFgDAULBgoDEWsMBAsABgAAAAAAAAAACwQKAQsFCgIGAAAAAAAAAAALAQsCCwMRVRIBAgEEAQcBAwEIAQUBBgEAAAAABQAGAAcACAAJAAoACwAMAAEABAACAAMAEQASABMAFAANAA4ADwAQAQIBAQAnAGsAiQEAigEAjQEACnN1aV9zeXN0ZW3YG6Ec6wsGAAAADAEAHAIcPgNakgME7AMKBfYDngMHlAe/DAjTE2AGsxQ2CukUCAzxFKYGDZcbBA+bGwIAMAEcAhACEgIUAhsCLwIzAjQALQAuADEASQBKAAYIAAECBwEAAAIABAEAAQMBDAEAAQULBAAGAwIACAoCAAkEBAAKBQgACwcEAAsIBAALCQQADA0EAA0MDAAAEwABAAAiAgEAACQDAQAAIQMBAAAjAwEAACYEAQAAKwQBAAAlBQEAACoFAQAAHwYBAAAgBwEAACcIAQAAHgkBAAA1CQEAACgDAQAAPwoBAAA9CgEAAD4KAQAARwoBAABACgEAADYKAQAAQgoBAAA4CgEAAEMKAQAAOQoBAABFCgEAADsKAQAARAsBAAA6CwEAAEYKAQAAPAoBAABBCgEAADcKAQAADwwNAAAZDg8AABoOEAAAGA4QAAQOFgECBwQEEScrAgcEBB0nKAIHBAcsGAEBCAgpIyQACw8lDQALExITAAsWARQACx4gAQALHx0BAAsgHgEACyEaAQALIhkBAAsjGgEACyQaAQALJRwBAAsmGwEACycfAQALKBoBAAsqHAEACysbAQALMg8UAAs1IAEACzYhAQALNyEBAAs4IQEACzkhAQALOiIBAAs7IQEACzwhAQALPSEBAAs+IQEACz8hAQALQCEBAAtBIQEAC0IhAQALQyEBAAtEIgEAC0UhAQALRiEBAAtHIQEAC0gTKQAlFSgXJxUlKiYqCAgECggMCwIBCAUDAwgLCAcHCAYAEAcIAAoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgGAgcIAAcIBgMHCAAGCA0DAwcIAAMHCAYEBwgACwMBCAUFBwgGBQcIAAoLAwEIBQsBAQMFBwgGAwcIAAgIBwgGAwcIAAYIDQUDBwgACgIGCAYEBwgACgIKAgYIBgsLAgEIBQsCAQgFBwgAAwMDAwMDAwcIBgELAgEIBQEHCAABBggKAQcICgMIAAgJAwcKCAwLAgEIBQMDCAsIBwcIBgEICQEDAgMICQMHCAQJAAkBAQgAAQkAEAcICgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgGAgcICgcIBgMHCAoGCA0DAwcICgMHCAYEBwgKCwMBCAUFBwgGBQcICgoLAwEIBQsBAQMFBwgGAwcICggIBwgGAwcICgYIDQUDBwgKCgIGCAYEBwgKCgIKAgYIBgEGCAYBBQsHCAoDAwsCAQgFCwIBCAUDAwMDAwcIBgIHCAoICgIHCAQJAAEJAQEICgIDCAoBBwkBB0JhbGFuY2UEQ29pbgZPcHRpb24DU1VJDFN0YWtlU3Vic2lkeQlTdGFrZWRTdWkOU3VpU3lzdGVtU3RhdGUTU3VpU3lzdGVtU3RhdGVJbm5lchVTdWlTeXN0ZW1TdGF0ZUlubmVyVjIQU3lzdGVtUGFyYW1ldGVycwlUeENvbnRleHQDVUlEH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAJVmFsaWRhdG9yA2FkZA1hZHZhbmNlX2Vwb2NoB2JhbGFuY2UKYm9ycm93X211dARjb2luBmNyZWF0ZQ1keW5hbWljX2ZpZWxkB2dlbmVzaXMcZ2VuZXNpc19zeXN0ZW1fc3RhdGVfdmVyc2lvbgJpZBhsb2FkX2lubmVyX21heWJlX3VwZ3JhZGURbG9hZF9zeXN0ZW1fc3RhdGUVbG9hZF9zeXN0ZW1fc3RhdGVfbXV0Bm9iamVjdAZvcHRpb24GcmVtb3ZlEHJlcG9ydF92YWxpZGF0b3IRcmVxdWVzdF9hZGRfc3Rha2UacmVxdWVzdF9hZGRfc3Rha2VfbXVsX2NvaW4VcmVxdWVzdF9hZGRfdmFsaWRhdG9yH3JlcXVlc3RfYWRkX3ZhbGlkYXRvcl9jYW5kaWRhdGUYcmVxdWVzdF9yZW1vdmVfdmFsaWRhdG9yInJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvcl9jYW5kaWRhdGUbcmVxdWVzdF9zZXRfY29tbWlzc2lvbl9yYXRlFXJlcXVlc3Rfc2V0X2dhc19wcmljZRZyZXF1ZXN0X3dpdGhkcmF3X3N0YWtlFHJvdGF0ZV9vcGVyYXRpb25fY2FwBnNlbmRlcidzZXRfY2FuZGlkYXRlX3ZhbGlkYXRvcl9jb21taXNzaW9uX3JhdGUhc2V0X2NhbmRpZGF0ZV92YWxpZGF0b3JfZ2FzX3ByaWNlDHNoYXJlX29iamVjdA1zdGFrZV9zdWJzaWR5DHN0YWtpbmdfcG9vbANzdWkKc3VpX3N5c3RlbRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyFHN5c3RlbV9zdGF0ZV92ZXJzaW9uCHRyYW5zZmVyCnR4X2NvbnRleHQVdW5kb19yZXBvcnRfdmFsaWRhdG9yKnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX25ldHdvcmtfYWRkcmVzcyl1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9uZXR3b3JrX3B1YmtleSZ1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wMnBfYWRkcmVzcyp1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wcmltYXJ5X2FkZHJlc3MqdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcHJvdG9jb2xfcHVia2V5KXVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3dvcmtlcl9hZGRyZXNzKHVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3dvcmtlcl9wdWJrZXkcdXBkYXRlX3ZhbGlkYXRvcl9kZXNjcmlwdGlvbhp1cGRhdGVfdmFsaWRhdG9yX2ltYWdlX3VybBV1cGRhdGVfdmFsaWRhdG9yX25hbWUrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX25ldHdvcmtfYWRkcmVzcyp1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfbmV0d29ya19wdWJrZXkndXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3AycF9hZGRyZXNzK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wcmltYXJ5X2FkZHJlc3MrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleSp1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MpdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3dvcmtlcl9wdWJrZXkcdXBkYXRlX3ZhbGlkYXRvcl9wcm9qZWN0X3VybAh2MV90b192Mgl2YWxpZGF0b3INdmFsaWRhdG9yX2NhcAd2ZXJzaW9uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAAFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFwgESwMAAwAAERcLAQsCCwMLBAsFCwYLBxErDAkRLAwKCwAKChIADAgNCA8ACwoLCTgACwg4AQIBAQQAARMLABEjCwELAgsDCwQLBQsGCwcLCAsJCwoLCwsMCw0LDgsPETECAgEEAAEFCwARIwsBETMCAwEEAAEFCwARIwsBETACBAEEAAEFCwARIwsBETICBQEEAAEGCwARIwsBCwIRNQIGAQQAAQYLABEjCwELAhE5AgcBBAABBgsAESMLAQsCETQCCAEEAAEGCwARIwsBCwIROAIJAQQAAQcLABEjCwELAgsDES4CCgEEAAEICwARIwsBCwILAwsEES8CCwEEAAEGCwARIwsBCwIRNgIMAQQAAQYLABEjCwELAhEtAg0BBAABBgsAESMLAQsCETsCDgEEAAEFCwARIwsBETcCDwEEAAEGCwARIwsBCwIRRQIQAQQAAQYLABEjCwELAhFDAhEBBAABBgsAESMLAQsCEUQCEgEEAAEGCwARIwsBCwIRTQITAQQAAQYLABEjCwELAhFGAhQBBAABBgsAESMLAQsCETwCFQEEAAEGCwARIwsBCwIRSAIWAQQAAQYLABEjCwELAhE+AhcBBAABBgsAESMLAQsCEUkCGAEEAAEGCwARIwsBCwIRPwIZAQQAAQYLABEjCwELAhFLAhoBBAABBgsAESMLAQsCEUECGwEEAAEHCwARIwsBCwILAxFKAhwBBAABBwsAESMLAQsCCwMRQAIdAQQAAQYLABEjCwELAhFMAh4BBAABBgsAESMLAQsCEUICHwEEAAEGCwARIwsBCwIRRwIgAQQAAQYLABEjCwELAhE9AiEAAAAQHQsCESMMCwoKLhEpBwIhBAoFEAsLAQsKAQcAJwsLCwMLBAsACwELBQsGCwcLCAsJCwoRKgIiAAAAAQQLABEkLgIjAAAAAQMLABEkAiQAAAAmLwoAEAEUBgEAAAAAAAAAIQQZCgAPAAoAEAEUOAIRTgwCBgIAAAAAAAAACgAPARUKAA8ACgAQARQLAjgDCgAPAAoAEAEUOAQMAQoBLhE6CwAQARQhBCkFLQsBAQcBJwsBAgAAAAEAFQAMc3Rha2luZ19wb29syB6hHOsLBgAAAAwBABYCFjoDUK8CBP8CJgWlA+ACB4UGkAkIlQ9gBvUPyAEKvRFCDP8R7QsN7B0cD4geBABJATACDwIQAhMCKwIvAkoCTQJOAk8ACAwAAAUHAAAHCAABBAcBAAACAAwAAwEEAQABBAIMAQABBgMHAAYLBAAHBgIACAkMAgcBBAEKCgIAAC0AAQAAPwIDAABABAUAAFQGBwAAUAgJAAAYCgMAAD0LAwAAPAwDAAA7DAMAAFUNCQAADA4DAABBBAUAABUOAwAATA8FAAA2EBEAAEgQBQAARxAFAAAmDxIAACQPEgAARRMIAABGEwMAACoUAwAAIxUSAAA5FhcAADMPBQAANA8FAAAnFhIAAB4YBQAAHxgFAAAiAxcAABIWAwABETQjAQABHDEDAQABIDYzAQMBJTQSAQABKDQSAQABLgMdAQABRDMdAQACLQAgAAMpKAUBAANFMB8BAANTIgUBAANWAx8BAAQdKSoBAAUsLQUABhccAwAGISMRAQgGLQAcAAgOLgMCBwQIETc4AgcECBQ3EgIHBAgtABsCBwQJPiQDAQwJTiQDAQgKGSYFAApDJicAMxokBSoeKR4uATUIJx4rHjQrMBooHiAFJQUiBSMFIQUfBTIaMRoBBwgLAQgABQcIAAsFAQgJBQMHCAsAAwcIAAgCBwgLAQMCBwgACAICAwsFAQgJAQgCAQsFAQgJAgcIAAsFAQgJAgcIAAcICwEHCAAEBwgAAwMDAgcIAAMBBggAAQYIAgEIBwEBAwcIAgMHCAsCBwgCCAICBggCBggCAgYIAAMBCAECBggBAwELCgIDCAECAwgBAQsKAgkACQEBCAgBCwMBCQABCAkBCwUBCQABCAQCCAIDAQYLBQEJAAEGCQACCQAFBgMLBQEICQMLBQEICQUDAQYICwEFAgcLBQEJAAsFAQkAAgsFAQkABwgLAQsGAQkAAQsGAQgJAwMIAQsFAQgJAgMDAwcLCgIJAAkBCQAJAQUDAwgBAwMCBwsFAQkAAwIHCwMBCQAJAAMLBQEICQUDAQkAAQYLAwEJAAIGCAILBQEICQIGCwMBCQAJAAIGCwoCCQAJAQkAAQYJAQMDCAEDA0JhZwdCYWxhbmNlBENvaW4CSUQGT3B0aW9uFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQNTVUkJU3Rha2VkU3VpC1N0YWtpbmdQb29sBVRhYmxlCVR4Q29udGV4dANVSUQVYWN0aXZhdGVfc3Rha2luZ19wb29sEGFjdGl2YXRpb25fZXBvY2gDYWRkA2JhZwdiYWxhbmNlBmJvcnJvdxhjaGVja19iYWxhbmNlX2ludmFyaWFudHMEY29pbghjb250YWlucxdkZWFjdGl2YXRlX3N0YWtpbmdfcG9vbBJkZWFjdGl2YXRpb25fZXBvY2gGZGVsZXRlD2RlcG9zaXRfcmV3YXJkcwVlcG9jaA5leGNoYW5nZV9yYXRlcwxleHRyYV9maWVsZHMEZmlsbAxmcm9tX2JhbGFuY2UOZ2V0X3N1aV9hbW91bnQQZ2V0X3Rva2VuX2Ftb3VudBBnZXRfd2l0aF9kZWZhdWx0AmlkFWluaXRpYWxfZXhjaGFuZ2VfcmF0ZRlpc19lcXVhbF9zdGFraW5nX21ldGFkYXRhC2lzX2luYWN0aXZlB2lzX25vbmUMaXNfcHJlYWN0aXZlFWlzX3ByZWFjdGl2ZV9hdF9lcG9jaAdpc19zb21lBGpvaW4Pam9pbl9zdGFrZWRfc3VpBG1hdGgDbWluA25ldwRub25lBm9iamVjdAZvcHRpb24bcGVuZGluZ19wb29sX3Rva2VuX3dpdGhkcmF3DXBlbmRpbmdfc3Rha2UUcGVuZGluZ19zdGFrZV9hbW91bnQdcGVuZGluZ19zdGFrZV93aXRoZHJhd19hbW91bnQacGVuZGluZ190b3RhbF9zdWlfd2l0aGRyYXcHcG9vbF9pZBFwb29sX3Rva2VuX2Ftb3VudBJwb29sX3Rva2VuX2JhbGFuY2UhcG9vbF90b2tlbl9leGNoYW5nZV9yYXRlX2F0X2Vwb2NoCXByaW5jaXBhbBVwcm9jZXNzX3BlbmRpbmdfc3Rha2UecHJvY2Vzc19wZW5kaW5nX3N0YWtlX3dpdGhkcmF3JHByb2Nlc3NfcGVuZGluZ19zdGFrZXNfYW5kX3dpdGhkcmF3cw9wdWJsaWNfdHJhbnNmZXIRcmVxdWVzdF9hZGRfc3Rha2UWcmVxdWVzdF93aXRoZHJhd19zdGFrZSByZXF1ZXN0X3dpdGhkcmF3X3N0YWtlX3ByZWFjdGl2ZQxyZXdhcmRzX3Bvb2wGc2VuZGVyBHNvbWUFc3BsaXQQc3BsaXRfc3Rha2VkX3N1aRZzdGFrZV9hY3RpdmF0aW9uX2Vwb2NoEXN0YWtlZF9zdWlfYW1vdW50DHN0YWtpbmdfcG9vbANzdWkKc3VpX2Ftb3VudAtzdWlfYmFsYW5jZQV0YWJsZQh0cmFuc2Zlcgp0eF9jb250ZXh0EXVud3JhcF9zdGFrZWRfc3VpCXZhbGlkYXRvcg12YWxpZGF0b3Jfc2V0BXZhbHVlF3dpdGhkcmF3X2Zyb21fcHJpbmNpcGFsEHdpdGhkcmF3X3Jld2FyZHMEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAMqaOwAAAAADCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAMIBQAAAAAAAAADCAYAAAAAAAAAAwgHAAAAAAAAAAMICAAAAAAAAAADCAkAAAAAAAAAAwgKAAAAAAAAAAMICwAAAAAAAAADCAwAAAAAAAAAAwgNAAAAAAAAAAMIDgAAAAAAAAADCA8AAAAAAAAAAwgQAAAAAAAAAAMIEQAAAAAAAAADCBIAAAAAAAAAAAILIQgIDQsDAQMWCwMBA0wDQgsFAQgJOAMaCwoCAwgBMgM1AzEDGwgEAQICSwM3AwICBCEICDYIB0cDOgsFAQgJAAMAABkSCgA4AAwBCgARLzgBOAEGAAAAAAAAAAA4AgYAAAAAAAAAAAsBBgAAAAAAAAAABgAAAAAAAAAABgAAAAAAAAAACwARJhIAAgEDAAAhLw4BOAMMBgoALhESIAQJBQ8LAAELBAEHCycKBgYAAAAAAAAAACQEFAUaCwABCwQBBxInCwQRLwoALjgECwMLARICDAUKABAAFAsGFgsADwAVCwULAjgFAgIDAAAlPQoACwERAwwEDAMKAi4RNwwHDgQ4AwwFCgAKBQoDCgIuETYRCQwGCwUOBjgDFgwICgAQARQKCBYKAA8BFQoAEAIUCwMWCgAPAhUKAC4REgQwCwARBwUyCwABDQQLBjgGAQsECwI4BwsHOAgLCAIDAwAALB8OARADFAoALjgEIQQJBQ0LAAEHAicLAA4BEAQUDAIuCwIRFwwDCwERBAwEDgMOBDgDERwLBAIEAAAACQgLABMCDAEBAREtCwECBQMAAAMPCgAQBRQOATgDFgoADwUVCwAPBgsBOAYBAgYDAAAtHAsBLhE2BgEAAAAAAAAAFgwDCgARBwoAEQgKAA8HCgMKABAFFAoAEAgUEgE4CQsACwMMAi4LAhEeAgcAAAADHQoAEAUUCgAQARQXCgAPBRUKABAIFAoAEAIUFwoADwgVBgAAAAAAAAAACgAPARUGAAAAAAAAAAALAA8CFQIIAwAAFx8KABAFFAoAEAgUEgEMAQoAEAUUCgAQABQWCgAPBRUOAQoAEAUUERwKAA8IFQYAAAAAAAAAAAsADwAVAgkAAAAvIQoACwMMBC4LBBEXDAYOBgsCERsMCAoICgEmBBQLCAsBFwwFBRYGAAAAAAAAAAAMBQsFCgAQBjgDESwMBwsADwYLBzgKAgoDAAADHQoADwcKAREdOAkKAC4REQQKBQ4LAAEHDycKAC4REiAEFAUYCwABBxEnCwAPCQsBOAsCCwMAADI7DgEQAxQKAC44BCEECQUPCwABCwIBBwInCgAuEREEFAUaCwABCwIBBxAnCgIuETcMBAsBEQQMAw4DOAMMBQoAEAUUCgUXCgAPBRUKABAIFAoFFwsADwgVCwMLAjgHCwQ4CAsFAgwDAAADEAoALhESIAQGBQoLAAEHDCcLATgMCwAPChUCDQEAAAMECwAQBRQCDgEAAAMECwAQAxQCDwEAAAMECwAQCzgDAhABAAADBAsAEAQUAhEBAAADBAsAEAk4DQISAQAAAwQLABAKOA4CEwEAAAMOCwIRLwoAEAMUCgAQBBQLAA8LCwE4ChICAhQBBAAFMAoAEAs4AwwDCgEKAyUECQUPCwABCwIBBwQnCwMKARcHACYEFgUcCwABCwIBBxMnCgEHACYEIQUnCwABCwIBBxMnCwALAQoCERMLAi4RNzgFAhUBBAA1GAoADgEMAi4LAhEWBAgFDAsAAQcNJwsBEwIMAwEBES0LAA8LCwM4BgECFgEAABIZCgAQAxQKARADFCEEEQsAEAQUCwEQBBQhDAIFFwsAAQsBAQkMAgsCAhcBAAAtLQoACgERGgQICwABER0CCgAQCgoBOA8LAREsDAMKABAJOBAUDAIKAwoCJgQpBRkKABAHCgM4EQQkCwAQBwsDOBIUAgsDBgEAAAAAAAAAFwwDBRQLAAERHQIYAQAAAwQLABAAFAIZAQAAAwQLABABFAIaAAAAEhEKABERBAgLAAEIDAIFDwsAEAk4EBQLASQMAgsCAhsAAAASIwoAEAwUBgAAAAAAAAAAIQQJCAwCBQ8KABANFAYAAAAAAAAAACEMAgsCBBULAAELAQIKABAMFDULATUYCwAQDRQ1GjQCHAAAABIjCgAQDBQGAAAAAAAAAAAhBAkIDAIFDwoAEA0UBgAAAAAAAAAAIQwCCwIEFQsAAQsBAgoAEA0UNQsBNRgLABAMFDUaNAIdAAAAAwQGAAAAAAAAAAAGAAAAAAAAAAASAQIeAAAAORYKAAsBERcMAw4DCgAQBRQRHAwECwAQCBQMAgsECwIhBBMFFQcKJwIABwAIAAkCAQICAAMABAAGAAUAAQACAgMBAAEBAFEAUgAMc3RvcmFnZV9mdW5ktQShHOsLBgAAAAsBAAYCBg4DFCwEQAgFSEkHkQGyAQjDAkAKgwMPDJIDaw39AwQPgQQCAAkBBAEKAAIEAAEABAEAAQIBAgAABgABAAADAgAAAA0DBAAADAMEAAEFCAQBAAEICQcBAAEOCgQBAAEPBQcBAAcGBAYFBgYGAQsBAQgCAQgABgcIAAsBAQgCCwEBCAILAQEIAgMDAQYIAAEDAAEIAgELAQEJAAIHCwEBCQALAQEJAAIHCwEBCQADAQYLAQEJAAdCYWxhbmNlA1NVSQtTdG9yYWdlRnVuZA1hZHZhbmNlX2Vwb2NoB2JhbGFuY2UEam9pbgNuZXcWbm9uX3JlZnVuZGFibGVfYmFsYW5jZQVzcGxpdAxzdG9yYWdlX2Z1bmQDc3VpFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXINdG90YWxfYmFsYW5jZRx0b3RhbF9vYmplY3Rfc3RvcmFnZV9yZWJhdGVzBXZhbHVlBHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAICDQsBAQgCBwsBAQgCAAMAAAUEOAALABIAAgEDAAAAHgoADwALAjgBAQoADwALAzgBAQoADwELATgBAQoADwELBTgCDAYKAA8ACwY4AQELAA8BCwQ4AgICAQAABQQLABABOAMCAwEAAAUICgAQATgDCwAQADgDFgIAAQAAAAsADHZvdGluZ19wb3dlcpcNoRzrCwYAAAAMAQAIAggMAxRXBGsEBW+GAQf1AbACCKUEYAaFBUYKywUQDNsF/gYN2QwED90MAgAWARUCCQASAAECAAACAgADAAQAAA0AAQAABgIDAAAPBAUAAAcGAQAAAwcBAAARCAEAAAQEAQAAEAEFAAAMAQUAAQcRAQEAAQgTFAEAAgULBQACCgsFAAILCwUAAw0VAQADDw4FAAMWDgUACQ0KDQEHCggCAAIGCggCAwIKCAEDAQYKCAIBAwIHCggBCAEDBwoIAQMDAgcKCAIKCAEEAwoIAQMDAQgCAgMDCAMIAQMKCAEDAwMDAQgBAQYIAgMDAwMEAwEDAwMHCgkACQADBwEDAwMDAwcIAQEGCgkAAQECBwgCAwwDAwMDAwMDAwMGCAIGCAIDCVZhbGlkYXRvcg9Wb3RpbmdQb3dlckluZm8RVm90aW5nUG93ZXJJbmZvVjITYWRqdXN0X3ZvdGluZ19wb3dlchBjaGVja19pbnZhcmlhbnRzE2RpdmlkZV9hbmRfcm91bmRfdXAWaW5pdF92b3RpbmdfcG93ZXJfaW5mbwZpbnNlcnQIaXNfZW1wdHkEbWF0aANtYXgDbWluEHF1b3J1bV90aHJlc2hvbGQQc2V0X3ZvdGluZ19wb3dlcgVzdGFrZQt0b3RhbF9zdGFrZRJ0b3RhbF92b3RpbmdfcG93ZXITdXBkYXRlX3ZvdGluZ19wb3dlcgl2YWxpZGF0b3IPdmFsaWRhdG9yX2luZGV4DXZhbGlkYXRvcl9zZXQGdmVjdG9yDHZvdGluZ19wb3dlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIECcAAAAAAAADCAsaAAAAAAAAAwjoAwAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAAAAgITAxYDAQIDEwMWAw4DAAMAAAkdBwAHAgcACgAuQQoRCxEMEQ0MBAoACgQMAS4LAREBDAMMAg0CCwQLAxEECgALAhEFCwAuEQYCAQAAAAw6CgARAgwIBgAAAAAAAAAADAIKAEEKDAQGAAAAAAAAAAAMB0ANAAAAAAAAAAAMBQoCCgQjBDMFEQoACgJCChEPDAYKBjUHADUYCgg1GjQKARENDAkKAgoJCwYSAQwDDQULAxEDCwcLCRYMBwsCBgEAAAAAAAAAFgwCBQwLAAELBQcACwcXAgIAAAAPHAYAAAAAAAAAAAwBCgBBCgwCBgAAAAAAAAAADAMKAQoCIwQYBQwLAwoACgFCChEPFgwDCwEGAQAAAAAAAAAWDAEFBwsAAQsDAgMAAAAQJwYAAAAAAAAAAAwECgAuQQ0MBQoECgUjBBkFCwoACgQMAi4LAkINEAAUDgEQABQkDAMFGwkMAwsDBCILBAYBAAAAAAAAABYMBAUGCwALAQsEOAACBAAAABJUBgAAAAAAAAAADAUKAC5BDQwGCgUKBiMEEAULCgIGAAAAAAAAAAAkDAMFEgkMAwsDBEoKAAoFQw0MCQoCCgYKBRcRCwwHCgEKCRABFAsHFhENDAgKAgsICgkQARQXEQ0MBAoJEAEUCgQWCgkPARULCRABFAoBJQQ9BUELAAEHBScLAgsEFwwCCwUGAQAAAAAAAAAWDAUFBgsAAQsCBgAAAAAAAAAAIQRRBVMHAycCBQAAAAsWDgE4ASAEEQUFDQFFDRMBAQwDDAIKAAsCQwoLAxEOBQALAAELAUYNAAAAAAAAAAACBgAAABZ3BgAAAAAAAAAADAMKAEEKDAQGAAAAAAAAAAAMCQoDCgQjBCMFDAoACgNCChEQDAwKDAYAAAAAAAAAACQEFgUaCwABBwYnCwkLDBYMCQsDBgEAAAAAAAAAFgwDBQcLCQcAIQQoBSwLAAEHAycGAAAAAAAAAAAMAQoBCgQjBHQFMwoBBgEAAAAAAAAAFgwCCgIKBCMEbwU8CgAKAUIKDAoKAAoCQgoMCwoKEQ8MBwoLEQ8MCAsKERAMBQsLERAMBgoHCggkBF0KBQoGJgRZBV0LAAEHBCcLBwsIIwRqCwULBiUEZgVqCwABBwQnCwIGAQAAAAAAAAAWDAIFNwsBBgEAAAAAAAAAFgwBBS4LAAECBwEAAAECBwACCAEAAAECBwECAQIBAQAUAA1zdGFrZV9zdWJzaWR5rgahHOsLBgAAAAwBAAwCDBYDIiUERwQFS0oHlQGwAgjFA0AGhQQcCqEEFAy1BLQBDekFCg/zBQQAEgEGAQcBDgEVARcAAwQAAQAMAAIBBAEAAQQCAgAFBAIAAAgAAQAABQIDAAAKBAUAARAHCAACEQ0OAQACGAsFAQADDwwFAAUKBAoFCwIBCAMDAw0HCAQBCAABBwgAAQsCAQgDAQYIAAEDAAEHCAQBCAEDBAsCAQgDAwEIAwEGCwIBCQACAwMCBwsCAQkAAwELAgEJAANCYWcHQmFsYW5jZQNTVUkMU3Rha2VTdWJzaWR5CVR4Q29udGV4dA1hZHZhbmNlX2Vwb2NoA2JhZwdiYWxhbmNlBmNyZWF0ZRtjdXJyZW50X2Rpc3RyaWJ1dGlvbl9hbW91bnQcY3VycmVudF9lcG9jaF9zdWJzaWR5X2Ftb3VudBRkaXN0cmlidXRpb25fY291bnRlcgxleHRyYV9maWVsZHMHZ2VuZXNpcwRtYXRoA21pbgNuZXcFc3BsaXQNc3Rha2Vfc3Vic2lkeRtzdGFrZV9zdWJzaWR5X2RlY3JlYXNlX3JhdGUbc3Rha2Vfc3Vic2lkeV9wZXJpb2RfbGVuZ3RoA3N1aRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyCnR4X2NvbnRleHQFdmFsdWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBBAQJwAAAAAAAAAAAAAAAAAAAwgAAAAAAAAAAAACBgcLAgEIAwsDCQMUAxMNDAgBAAMAAAYTCgMHAEslBAYFCgsEAQcBJwsABgAAAAAAAAAACwELAgsDCwQRAxIAAgEDAAAJOQoAEAAUCgAQATgAEQYMAwoADwELAzgBDAIKABACFAYBAAAAAAAAABYKAA8CFQoAEAIUCgAQAxQZBgAAAAAAAAAAIQQ1CgAQABQ1CgAQBBQ1GAcAGgwBCgAQABQLATQXCwAPABUFNwsAAQsCAgIBAAAGCAoAEAAUCwAQATgAEQYCAAIAAAABAAMABAANABYADXZhbGlkYXRvcl9jYXCBBqEc6wsGAAAADAEACAIIFAMcKgRGBAVKNgeAAeICCOIDQAaiBCIKxAQNDNEEcA3BBQQPxQUGABIBCgEOAQ8AAwwAAAQCAAEABwABAgQAAwECAAAQAAEAABQCAQAACQMEAAAIAAUAAQYNBAEIAQcKCwACCw4GAQwDDAgJAAQMBgwBBggAAQYFAQYIAQIFBwgEAQgCAQgBAAQBCAAIAgUBBggEAQUBBwgEAQgDAQgAAQYJAAIJAAUCSUQJVHhDb250ZXh0A1VJRB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwFVZhbGlkYXRvck9wZXJhdGlvbkNhcBxhdXRob3JpemVyX3ZhbGlkYXRvcl9hZGRyZXNzAmlkA25ldxNuZXdfZnJvbV91bnZlcmlmaWVkM25ld191bnZlcmlmaWVkX3ZhbGlkYXRvcl9vcGVyYXRpb25fY2FwX2FuZF90cmFuc2ZlcgZvYmplY3QPcHVibGljX3RyYW5zZmVyBnNlbmRlchZzdWlfc3lzdGVtX3N0YXRlX2lubmVyCHRyYW5zZmVyCnR4X2NvbnRleHQgdW52ZXJpZmllZF9vcGVyYXRpb25fY2FwX2FkZHJlc3MJdmFsaWRhdG9yDXZhbGlkYXRvcl9jYXANdmFsaWRhdG9yX3NldB52ZXJpZmllZF9vcGVyYXRpb25fY2FwX2FkZHJlc3MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgYIAwUFAQIBBQUAAwAABgMLABAAAgEDAAAGAwsAEAECAgMAAAcjCgEuEQcMBQoFBwAhBAsIDAIFDwsFCgAhDAILAgQSBRYLAQEGAAAAAAAAAAAnCwERBQoAEgAMAw4DOAAMBAsDCwA4AQsEAgMDAAAGBQsAEAAUEgECAAEBAAANABEAEwANdmFsaWRhdG9yX3NldLZQoRzrCwYAAAAMAQAzAjNwA6MBhgYEqQeFAQWuCNIJB4AStxcItylgBpcqwwEK2iuNAQznLPsiDeJPEA/yTwUAnwEBZwGnAQIeAh8COQJlAnECjQECkQECkgECmAECpQECpgEAiQEAmwEAngEAowEAqgEAEwQAAA4DAAAPAwAAEAMAABEDAAEEBwEAAAMADAAEAQQBAAEGAwcABwIGAQIABwYGAQIACAcCAAkJDAIHAQQBCgoEAQQBCwsCAAwVBwIBAAAADRYHAQMADgUHAA4ICAAPDQQAEAwMABASAgARFAQAAGAAAQAAfAIDAAB+BAMAAHsFAwAAHAYDAAB9BAMAAHoHAwAAgAEIAwAAfwkDAAAbCgMAAJoBCwMAADQMAwAALw0OAACVAQ0OAACiAQ8OAACgAQ8OAAChAQ8QAACLAQ0RAABjDQ4AAFEPEgAAVAYSAABTExIAACsTDgAAVQYSAAAqFA4AAEQVFgAAPBcYAAA9GRgAAEcaGwAASBwWAABBHRYAAEseFgAASR8WAABKHxYAAEwXIAAAQiEgAABDDyAAAEYPIAAAqQEiIwAAciQDAAB1JQMAACMmAwAAdCcDAACFASgDAABzKQMAACIqDgAAGisDAAAmLC0AACcuLwAAKDAxAAAlMjEAADMzAwAANjQDAACQARoOAAAYDSoAAFoPEgAAVzUSAAExb1EBAAE7UFEBAAFZTxIBAAFkA28BAAGEAVFvAQACKVISAQACVn0SAQACeWFRAQADYDhCAAQylAEDAQAEXJUBDgEABIYBkwGUAQEABKQBVA4BAAU1UQMBAwZNbhABCAdgZ2gBAgdhZWYBAgdwaWUBAgkZPAMCBwQJIERXAgcECSFJWQIHBAkpRBICBwQJYDg5AgcECXlJSgIHBAogbW4BBAohcnMBBAo3OD0BBApWahIBBApeag4BBApvhwFRAQQKdk0DAQQLOEgOAAuBAUg7AAwpXRICAQAMNwNBAgEADEBdVwIBAAxFXlkCAQAMT2ADAgEADFaCARICAQAMXYIBgwECAQAMbo4BXwIBAAx5Xl8CAQAMgwGCAQ4CAQANKYQBEgEDDVCPAYMBAQMNVoYBEgEDDXmFAQMBAw5qVhAADxdLAwAPGhYDAA8kIA4ADy1LAwAPLpYBAwAPNBYDAA8+IA4AD1JsEgAPWCASAA9mIHsAD22YAZkBAA9zigEDAA96VQMAD39LAwAPgAFYAwAPiAEgDgAPigEgEAAPjgEgOwAPlgEgDgAPqgEgDgAQYnkjABCZAXl1ABCoAXR1ABEsRUYAETBGOgARX1oWABJ3Aw4AEoIBKwMAEpcBAw4ATzdLN1M6Tz5PP1tATj9LP1A/UDdLPlc6Ow46Dj4ORVNON0w3Tj5NPlpAYkBdQF5AQDpJDkgOSg5VOlE6TT89DjwOOQ5SOkd6Pw5Gf1qBAWKBAWCBAV2BAWQ7ZztmO1Q6VjpGiAFbYl5iX4EBYYEBZTtjYlpiXGJEU0NTQlNcgQE+O0aaAQIKCBMHCA4BCAADBwgACBMHCA4AAgcIAAcIDgMHCAADBwgOAgYIAAYIEwQHCAAFCwcBCAsHCA4DBwgACBIHCA4DBwgAAwYIDgkHCAAHCwcBCAsHCwcBCAsHCw8CBQsQAQUDAwMDBwgOBgcIAAMDAwcLDwIFCxABBQcIDgEHCAABBggAAQMCBggABQEICAEGCwwCCAgFAQECBgoIEwYIEwIGCw0BCBMGCBMCBwgABQEHCBMCBgoIEwUBCwUBAwIGCw0BCBMFAgYKCBMGCgUBCgMCBwoIEwUDBwgABQEDBwgABggVAQIHCAAGCA4BBggTAwcIAAUCAwcIAAYIFAIBCBUDBwgABwsPAgULEAEFBwgOBQcIAAgTBwsPAgULEAEFAQcIDgIHCw8CBQsQAQUFAgcIAAMBBwoDAgcKCBMHCA4BBgoIEwEHCggTBAoDAwYKAwYKAwQDCw8CAwMDCw8CAwMCBggACw8CBQsQAQUBCgUEBgoIEwMDAwIKAwoDCQYKCBMDAwoDCgMDCw8CAwMDCw8CAwMGBwoIEwYKAwYKAwcLBwEICwcLBwEICwcIDgYDBgoIEwYKAwYKAwYLDwIFCxABBQYKBQIGCAAICAYDAwsMAggIBQMGCBMIAAIICAUBBwgOAQsMAgkACQEBCBMBBQMHCwwCCQAJAQkACQEBCw0BCQACCAgIFgIFCBYCBQMBCw8CCQAJAQEIBgQGCBMGCBMBBQIGCwwCCQAJAQkAAggTBwgOAQgWAwgICBMFAQYIDgIHCwwCCQAJAQkAAQkBAgcIEwMFBggTBggTAQgTBQIHCw0BCQAJAAMFAwsFAQMBBgsFAQkAAQcLBQEJAAEJAAIGCgkABgkAAQgLAQYLBwEJAAQHCBMLBwEICwUHCA4BBggSAQYJAQMHCBMIEgcIDgEHCQEBBwgWDgsPAgULEAEFBgoFCgMKAwsPAgMDCw8CAwMDCgUDAwMDCgMKAwgDAwcDAwgTCBMFBggTAgYLDwIJAAkBBgkAAgcLDwIJAAkBBgkAAgkACQEDBwsPAgkACQEJAAkBAgcKCQADAgMDCgoLCQEDAwMLCgEDAwMDAwYIEwYKCBMBCwkBAwIDCQABCwkBCQABCgsJAQkAAQsKAQkAAQcLCgEJAAEGCw0BCQADAwMDAgYIEwYIEwIGCw0BCQADAQYJAAELBQEJAAUFAwsFAQMDCgMEAwMLBQEDCwUBAwIHCw0BCQADAQcJAAEGCBUBBgUCAwsFAQMGAQEDAwsFAQMLBQEDBQUGCBMICAUGCBMBBggUAQgUAQYICAIDCBMBBgoJAAMDBQgIAQgEBwYFBgUDAwYFCgUHCxABBQIFCxABBQEGCw8CCQAJAQEKCQACBgsQAQkABgkAAgcLEAEJAAYJAAEGCxABCQABBwsNAQkAAQgDBgMDAwMDAwIHCBMHCA4EAwMDBggTBwsPAgMDCw8CAwMEBAMDAwUKBQYKCBMLEAEFCgUFAQcLDwIJAAkBAQsQAQkABgMDBAoDCgMDEQMDAwoDAwoDAwQDAwMDAwMDAwQIAwMLBwEICwMHCBMFBAsHAQgLAgcLBwEJAAMBCwcBCQACBwsHAQkACwcBCQACBwgTCwcBCAsICgUDAwMDCgUGCBMFAgYIEwMBCBEBCAIDQmFnB0JhbGFuY2UFRW50cnkCSUQGT3B0aW9uFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQ1Qcmlvcml0eVF1ZXVlA1NVSQlTdGFrZWRTdWkFVGFibGUIVGFibGVWZWMJVHhDb250ZXh0H1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAJVmFsaWRhdG9yF1ZhbGlkYXRvckVwb2NoSW5mb0V2ZW50GVZhbGlkYXRvckVwb2NoSW5mb0V2ZW50VjISVmFsaWRhdG9ySm9pbkV2ZW50E1ZhbGlkYXRvckxlYXZlRXZlbnQVVmFsaWRhdG9yT3BlcmF0aW9uQ2FwDFZhbGlkYXRvclNldBBWYWxpZGF0b3JXcmFwcGVyBlZlY01hcAZWZWNTZXQIYWN0aXZhdGURYWN0aXZlX3ZhbGlkYXRvcnMDYWRkGmFkanVzdF9zdGFrZV9hbmRfZ2FzX3ByaWNlDWFkdmFuY2VfZXBvY2gmYXNzZXJ0X25vX3BlbmRpbmdfb3JfYWN0aXZlX2R1cGxpY2F0ZXMSYXRfcmlza192YWxpZGF0b3JzA2JhZwdiYWxhbmNlBmJvcnJvdwpib3Jyb3dfbXV0FmNhbGN1bGF0ZV90b3RhbF9zdGFrZXMmY2xlYW5fcmVwb3J0X3JlY29yZHNfbGVhdmluZ192YWxpZGF0b3IPY29tbWlzc2lvbl9yYXRlJGNvbXB1dGVfYWRqdXN0ZWRfcmV3YXJkX2Rpc3RyaWJ1dGlvbhpjb21wdXRlX3Jld2FyZF9hZGp1c3RtZW50cxpjb21wdXRlX3NsYXNoZWRfdmFsaWRhdG9ycyZjb21wdXRlX3VuYWRqdXN0ZWRfcmV3YXJkX2Rpc3RyaWJ1dGlvbghjb250YWlucxljb3VudF9kdXBsaWNhdGVzX3RhYmxldmVjFGNvdW50X2R1cGxpY2F0ZXNfdmVjCWNyZWF0ZV92MQpkZWFjdGl2YXRlFWRlcG9zaXRfc3Rha2VfcmV3YXJkcxpkZXJpdmVfcmVmZXJlbmNlX2dhc19wcmljZQdkZXN0cm95DGRlc3Ryb3lfc29tZQxkZXN0cm95X3plcm8RZGlzdHJpYnV0ZV9yZXdhcmQaZWZmZWN0dWF0ZV9zdGFnZWRfbWV0YWRhdGEEZW1pdBtlbWl0X3ZhbGlkYXRvcl9lcG9jaF9ldmVudHMFZW1wdHkFZXBvY2gFZXZlbnQMZXh0cmFfZmllbGRzB2V4dHJhY3QOZmluZF92YWxpZGF0b3IdZmluZF92YWxpZGF0b3JfZnJvbV90YWJsZV92ZWMJZ2FzX3ByaWNlB2dlbmVzaXMDZ2V0MGdldF9hY3RpdmVfb3JfcGVuZGluZ19vcl9jYW5kaWRhdGVfdmFsaWRhdG9yX211dDBnZXRfYWN0aXZlX29yX3BlbmRpbmdfb3JfY2FuZGlkYXRlX3ZhbGlkYXRvcl9yZWYYZ2V0X2FjdGl2ZV92YWxpZGF0b3JfcmVmJWdldF9jYW5kaWRhdGVfb3JfYWN0aXZlX3ZhbGlkYXRvcl9tdXQHZ2V0X211dBlnZXRfcGVuZGluZ192YWxpZGF0b3JfcmVmFWdldF92YWxpZGF0b3JfaW5kaWNlcxFnZXRfdmFsaWRhdG9yX211dBpnZXRfdmFsaWRhdG9yX211dF93aXRoX2N0eC9nZXRfdmFsaWRhdG9yX211dF93aXRoX2N0eF9pbmNsdWRpbmdfY2FuZGlkYXRlcyNnZXRfdmFsaWRhdG9yX211dF93aXRoX3ZlcmlmaWVkX2NhcBFnZXRfdmFsaWRhdG9yX3JlZgJpZBNpbmFjdGl2ZV92YWxpZGF0b3JzBmluc2VydAlpbnRvX2tleXMiaXNfYWN0aXZlX3ZhbGlkYXRvcl9ieV9zdWlfYWRkcmVzcwxpc19kdXBsaWNhdGUWaXNfZHVwbGljYXRlX3ZhbGlkYXRvciJpc19kdXBsaWNhdGVfd2l0aF9hY3RpdmVfdmFsaWRhdG9yI2lzX2R1cGxpY2F0ZV93aXRoX3BlbmRpbmdfdmFsaWRhdG9yCGlzX2VtcHR5FWlzX2luYWN0aXZlX3ZhbGlkYXRvcgxpc19wcmVhY3RpdmUHaXNfc29tZRZpc192YWxpZGF0b3JfY2FuZGlkYXRlDGlzX3ZvbHVudGFyeQRqb2luBGtleXMGbGVuZ3RoHGxvYWRfdmFsaWRhdG9yX21heWJlX3VwZ3JhZGUDbmV3CW5ld19lbnRyeRNuZXdfZnJvbV91bnZlcmlmaWVkGm5leHRfZXBvY2hfdmFsaWRhdG9yX2NvdW50BG5vbmUGb2JqZWN0EG9wZXJhdGlvbl9jYXBfaWQGb3B0aW9uGXBlbmRpbmdfYWN0aXZlX3ZhbGlkYXRvcnMQcGVuZGluZ19yZW1vdmFscwdwb29sX2lkE3Bvb2xfc3Rha2luZ19yZXdhcmQYcG9vbF90b2tlbl9leGNoYW5nZV9yYXRlIXBvb2xfdG9rZW5fZXhjaGFuZ2VfcmF0ZV9hdF9lcG9jaANwb3AIcG9wX2JhY2sHcG9wX21heA5wcmlvcml0eV9xdWV1ZRhwcm9jZXNzX3BlbmRpbmdfcmVtb3ZhbHMkcHJvY2Vzc19wZW5kaW5nX3N0YWtlc19hbmRfd2l0aGRyYXdzGnByb2Nlc3NfcGVuZGluZ192YWxpZGF0b3JzG3Byb2Nlc3NfdmFsaWRhdG9yX2RlcGFydHVyZQlwdXNoX2JhY2sQcXVvcnVtX3RocmVzaG9sZBpyZWZlcmVuY2VfZ2FzX3N1cnZleV9xdW90ZQZyZW1vdmURcmVxdWVzdF9hZGRfc3Rha2UVcmVxdWVzdF9hZGRfdmFsaWRhdG9yH3JlcXVlc3RfYWRkX3ZhbGlkYXRvcl9jYW5kaWRhdGUYcmVxdWVzdF9yZW1vdmVfdmFsaWRhdG9yInJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvcl9jYW5kaWRhdGUbcmVxdWVzdF9zZXRfY29tbWlzc2lvbl9yYXRlFnJlcXVlc3Rfd2l0aGRyYXdfc3Rha2UGc2VuZGVyEHNldF92b3RpbmdfcG93ZXIEc2l6ZQRzb21lEXNvcnRfcmVtb3ZhbF9saXN0BXNwbGl0BXN0YWtlDHN0YWtlX2Ftb3VudAxzdGFraW5nX3Bvb2wPc3Rha2luZ19wb29sX2lkFXN0YWtpbmdfcG9vbF9tYXBwaW5ncxtzdG9yYWdlX2Z1bmRfc3Rha2luZ19yZXdhcmQDc3VpC3N1aV9hZGRyZXNzFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIdc3VtX3ZvdGluZ19wb3dlcl9ieV9hZGRyZXNzZXMFdGFibGUJdGFibGVfdmVjGnRhbGx5aW5nX3J1bGVfZ2xvYmFsX3Njb3JlF3RhbGx5aW5nX3J1bGVfcmVwb3J0ZXJzC3RvdGFsX3N0YWtlEnRvdGFsX3N0YWtlX2Ftb3VudBJ0b3RhbF92b3RpbmdfcG93ZXIKdHhfY29udGV4dCB1bnZlcmlmaWVkX29wZXJhdGlvbl9jYXBfYWRkcmVzcyd1cGRhdGVfYW5kX3Byb2Nlc3NfbG93X3N0YWtlX2RlcGFydHVyZXMJdmFsaWRhdG9yEXZhbGlkYXRvcl9hZGRyZXNzFHZhbGlkYXRvcl9jYW5kaWRhdGVzDXZhbGlkYXRvcl9jYXANdmFsaWRhdG9yX3NldBZ2YWxpZGF0b3Jfc3Rha2VfYW1vdW50GXZhbGlkYXRvcl9zdGFraW5nX3Bvb2xfaWQcdmFsaWRhdG9yX3RvdGFsX3N0YWtlX2Ftb3VudBF2YWxpZGF0b3Jfd3JhcHBlcgV2YWx1ZQd2ZWNfbWFwB3ZlY19zZXQGdmVjdG9yHnZlcmlmaWVkX29wZXJhdGlvbl9jYXBfYWRkcmVzcwp2ZXJpZnlfY2FwDHZvdGluZ19wb3dlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIBAQIBAgIBAwQQECcAAAAAAAAAAAAAAAAAAAMIAMqaOwAAAAADCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAMIBQAAAAAAAAADCAYAAAAAAAAAAwgHAAAAAAAAAAMICAAAAAAAAAADCAkAAAAAAAAAAwgKAAAAAAAAAAMICwAAAAAAAAADCAwAAAAAAAAAAwgNAAAAAAAAAAMIZQAAAAAAAAAKAwEACgUBAAACCZUBAxgKCBNoCw0BCBNpCgOLAQsMAggIBU4LDAIICAgWnQELDAIFCBYdCw8CBQM6CAYBAgo4A5wBBXgDhwEDJANrA4wBA2wIEZQBCgWTAQMCAgs4A5wBBXgDhwEDqgEDJANrA4wBA2wIEZQBCgWTAQMDAgM4A5wBBYoBCAgEAgQ4A5wBBYoBCAhbAQADAAA2Mw4AES0MBQoBOAAMBA4AQToMAwYAAAAAAAAAAAwCCgIKAyMEHwUQDgAKAkI6DAYNBAoGEXkLBhF6OAELAgYBAAAAAAAAABYMAgULCwULAAoBOAJADgAAAAAAAAAACwQKATgDCgE4BDgFCwERQRIADAcNBw8AEYQBCwcCAQMAAENFCgAOAQwDLgsDERQgBBEKAA4BDAQuCwQRFyAMBQUTCQwFCwUEFgUcCwABCwIBBwcnDgERegwGCgAQAQoGOAYgBCYFLAsAAQsCAQcLJw4BEXEEMAU2CwABCwIBBwwnCgAPAg4BEXkLBjgBCwAPAQ4BEXoLAQsCEYABOAcCAgMAAEc1CgEuEVkMBAoAEAEKBDgGBAoFEAsAAQsBAQcNJwoADwELBDgIEYEBDAMOAxFxBBoFIAsAAQsBAQcMJw4DEXkMAgoADwIKAjgJAQ0DCgEuEVgRbAsADwMLAgsDCwERgAE4CgIDAwAATEULAi4RWQwHCgAQAQoHOAYECgUOCwABBw0nCgAPAQsHOAgRgQEMBgoADgYMAy4LAxEUIAQlCgAOBgwELgsEERcgDAUFJwkMBQsFBCoFLgsAAQcHJw4GEXEEMgU2CwABBwwnDgYRewsBJgQ8BUALAAEHCicLAA8ECwY4CwIEAwAAAxAKABAACgERFgsAEAQLAREYFgYBAAAAAAAAACEEDQUPBwcnAgUDAABOJAsBLhFZDAIKABAACwIRGgwEDgQ4DAQNBRELAAEHCScNBDgNDAMKABAFDgM4DiAEGwUfCwABBxAnCwAPBQsDRA4CBgMAAAMWDgI4DwcEJgQGBQwLAAELAwEHDycLAAsBERkLAgoDLhFZCwMRdQIHAwAANysOARFoDAMKABACCgM4EAQWCgAQAg4BEWg4ERQMBAsACwQRGQsBCwIRdwUqCgAQAwoDOBIEHAUiCwABCwIBBwgnCwAPAwsDOBMRggELAQsCEXcCCAMAADsKCwIRWQwDCwAPAAsDER0LARF2AgkDAABbbgoILhFYBgEAAAAAAAAAFgwPEYUBDBQKABAAChQKAS44DwoCLjgPETEMFgwVCgAKAxQMCS4LCREwDBAKABAADhARNQwRCgAQAA4QERwLBA4VDhYRLwwODBMMDQwSCgAQAAsUCxELFQsWCxILDQsTCw4RMgwMDAsKAA8ADgsODAsBCwIKCBEzCgAPABEuCgAPAAoIESwKDwoAEAAOCw4MCgMOEAwKLgsKETQKAAsPESoKAAoDCggRJwoACwULBgsHCwMLCBEKCgAQABEtCgAPBhUKAA8AEYQBCwARCwIKAAAAXGoKABAAQToMBwoHBgAAAAAAAAAAJARjBQkLBwYBAAAAAAAAABcMBwoAEAAKB0I6DA0KDRF6DAwLDRF7DAkKCQoBJgQoCgAQBw4MOBQEJwoADwcODDgVAQEFYgsJCgImBFcKABAHDgw4FARACgAPBw4MOBYMCAoIFAYBAAAAAAAAABYKCBULCBQMBgVHCgAPBwsMBgEAAAAAAAAAOBcGAQAAAAAAAAAMBgsGCgMkBFYKAA8ACgc4GAwKCgALCgoECQoFESgFYgoADwAKBzgYDAsKAAsLCgQJCgURKAUECwQBCwABCwUBAgsAAABiGAoAEABBOgwCBgAAAAAAAAAADAEKAQoCIwQVBQsKAA8ACgFDOhFuCwEGAQAAAAAAAAAWDAEFBgsAAQIMAQAAYzwLABAADAoKCkE6DANAZAAAAAAAAAAADAEGAAAAAAAAAAAMAgoCCgMjBB8FDwoKCgJCOgwJDQEKCRFvCwkRfDgZRGQLAgYBAAAAAAAAABYMAgUKCwoBCwE4GgwEBgAAAAAAAAAADAcRhQERgwEXDAgGAAAAAAAAAAAMBQoHCggjBDoFMQ0EOBsMBgwFCwcLBhYMBwUsCwUCDQEAAAMECwAQBhQCDgEAAAMGCwAQAAsBESIRewIPAQAAAwYLABAACwERIhF4AhABAAADBgsAEAALAREiEXkCEQEAAAMDCwAQAgISAwAAAwwKABAAQToKABAFQQ4XCwAQBDgcFgITAwAAGAgLABAACwERGgwCDgI4DAIUAAAAAwULABAACwERFQIVAwAAAwYLAAsBERYGAAAAAAAAAAAkAhYAAABrIQoAQToMAwYAAAAAAAAAAAwCBgAAAAAAAAAADAQKAgoDIwQbBQwKAAoCQjoKARFwBBYLBAYBAAAAAAAAABYMBAsCBgEAAAAAAAAAFgwCBQcLAAELAQELBAIXAAAAAwcLABAECwERGAYAAAAAAAAAACQCGAAAAGshCgA4HAwDBgAAAAAAAAAADAIGAAAAAAAAAAAMBAoCCgMjBBsFDAoACgI4HQoBEXAEFgsEBgEAAAAAAAAAFgwECwIGAQAAAAAAAAAWDAIFBwsAAQsBAQsEAhkAAAADEAoAEAEKATgGBAsLAA8BCwE4HhGCAQILAA8ACwERHQIaAAAAYh8KAEE6DAMGAAAAAAAAAAAMAgoCCgMjBBsFCgoACgJCOhF6CgEhBBYLAAELAjgfAgsCBgEAAAAAAAAAFgwCBQULAAE4IAIbAAAAYh8KADgcDAMGAAAAAAAAAAAMAgoCCgMjBBsFCgoACgI4HRF6CgEhBBYLAAELAjgfAgsCBgEAAAAAAAAAFgwCBQULAAE4IAIcAAAAcC4KAUE7DAUGAAAAAAAAAAAMAwcUDAYKAwoFIwQoBQwKAQoDQjsUDAIKAAsCERoMBA4EOAwEGQUfCwABCwEBBwknDQYLBDghRA4LAwYBAAAAAAAAABYMAwUHCwABCwEBCwYCHQMAAE4WCgALAQwCLgsCERoMBA4EOAwECwUPCwABBwknDQQ4DQwDCwALA0M6Ah4AAABxLQoAEAAKAREaDAUOBTgMBBANBTgNDAMLAA8ACwNDOgIKABAECgERGwwGDgY4DAQgDQY4DQwECwAPBAsEOCICCwIEIwUnCwABBw4nCwAPAQsBOB4RggECHwMAAAMHCwALARF/FAsCER4CIAMAADsICwERWQwCCwALAgkRHgIhAwAAOwgLARFZDAILAAsCCBEeAiIAAAB2EwoACwERGgwDDgM4DAQIBQwLAAEHCScNAzgNDAILAAsCQjoCIwMAAHc5CgAQAAoBERoMBw4HOAwECwgMAwUPCgIHACEMAwsDBBkNBzgNDAULABAACwVCOgIKABAECgERGwwIDgg4DAQkCAwEBSgLAgcBIQwECwQEMg0IOA0MBgsAEAQLBjgdAgsADwELATgeEYIBLgIkAQAAdhUKABAACwERGgwDDgM4DAQJBQ0LAAEHCScNAzgNDAILABAACwJCOgIlAQAAdhUKABAECwERGwwDDgM4DAQJBQ0LAAEHEScNAzgNDAILABAECwI4HQImAwAAeCcKARF+FAwGCgIHACEEEAsACwYMAy4LAxEkDAQFFQsACwYLAhEjDAQLBAwHCgE4IwwFCwcRcg4FIQQgBSQLAQEHEycLARF9AicAAAB8IAoADwURKwoAEAU4JCAEGQUJCgAPBUUODAMKAA8ACwM4GAwECgALBAoBCAoCESgFAwsBAQsAAQsCAQIoAAAAfjoKBC4RWAYBAAAAAAAAABYMBQ4BEXoMBg4BEXkMBwoADwIKBzgJAQoAEAcOBjgUBBwKAA8HDgY4FQEBCgAQBhQOARF7FwoADwYVCwIKBhEpCgULBg4BEXkLAxIEOCUNAQsFEWwLAA8DCwcLAQsEEYABOAoCKQAAAIABRQoADgEMAi4LAjgmBAwKAA4BOCcBAQoALjgoDAcOB0E7DAUGAAAAAAAAAAAMBAoECgUjBEIFGg4HCgRCOwwGCgAKBjgpDAgKCA4BDAMuCwM4KgQ5CggOATgrCwguOCwENgoACwY4JwEBBTgLBgEFPQsIAQsGAQsEBgEAAAAAAAAAFgwEBRULAAECKgAAADocCgAQBDgtIAQZBQYKAA8EOC4MAg0CCgERaQoBDgIReg4CEXkSAzgvCgAPAAsCRDoFAAsAAQIrAAAAiQE5CgAuQQ4MBgYBAAAAAAAAAAwECgQKBiMENgULCgAKBAwBLgsBQg4UDAMKBAwFCgUGAAAAAAAAAAAkBDEFGgsFBgEAAAAAAAAAFwwFCgAKBQwCLgsCQg4UCgMkBCkFKgUxCgAKBQoFBgEAAAAAAAAAFkcOBRULBAYBAAAAAAAAABYMBAUGCwABAiwAAABiGgoALkE6DAMGAAAAAAAAAAAMAgoCCgMjBBUFCwoACgJDOgoBEXQLAgYBAAAAAAAAABYMAgUGCwABCwEBAi0AAACLAR4GAAAAAAAAAAAMAwoAQToMAgYAAAAAAAAAAAwBCgEKAiMEGgUMCgAKAUI6DAQLAwsEEXsWDAMLAQYBAAAAAAAAABYMAQUHCwABCwMCLgAAAGIXCgAuQToMAgYAAAAAAAAAAAwBCgEKAiMEFAULCgAKAUM6EWoLAQYBAAAAAAAAABYMAQUGCwABAi8AAACMAUUGAAAAAAAAAAAMCDgwDAQGAAAAAAAAAAAMCTgwDAUNAC44JCAEPAUODQBFDgwKCgIKCkIOFDUKATUYBwMaDAYNBAoKCgY0ODELCAsGNBYMCAoDCgpCDhQ1CgE1GAcDGgwHDQULCgoHNDgxCwkLBzQWDAkFCAsDAQsCAQsICwQLCQsFAjAAAACNASgHFQwFDgE4MiAEJAUHDQE4MwwEDAYKAAoGERMEEAUUCwABBwUnCgAQAAwDCwQ4NAwCCwMOAhE1EYMBJgQjDQULBkQ7BQILAAELBQIxAAAAkAEvQA4AAAAAAAAAAAwHQA4AAAAAAAAAAAwICgBBOgwFCwMKBRoMCQYAAAAAAAAAAAwECgQKBSMEKgUSCgAKBEI6EXw1CgI1GAoBNRoMBg0HCwY0RA4NCAoJRA4LBAYBAAAAAAAAABYMBAUNCwABCwcLCAIyAAAAkQFsCwELAhcMFkAOAAAAAAAAAAAMDEAOAAAAAAAAAAAMDgoAQToMFAoUDgY4NRcMFQYAAAAAAAAAAAwTChMKFCMEZwUXCgAKE0I6EXw1DBkOAwoTQg4UDBcOBg4TODYEMA4GDhM4NxQMDwsXCw8XDAkFPQoFNQsZGAoWNRoMEAsXCxA0FgwJCwkMCw0MCwtEDg4EChNCDhQMGA4IDhM4NgRVDggOEzg3FAwRCxgLERcMCgVdCgcKFRoMEgsYCxIWDAoLCgwNDQ4LDUQOCxMGAQAAAAAAAAAWDBMFEgsAAQsMCw4CMwAAAJIBaQoALkE6DAcKBwYAAAAAAAAAACQECQUXCwABCwQBCwMBCwUBCwIBCwEBBxInBgAAAAAAAAAADAYKBgoHIwRcBR4KAAoGQzoMCgoBCgZCDhQMCQoDCgk4OAwICwk1CgouEWs1GAcDGgwMDQgLDDQ4OAwNDQ0KBAoCCgZCDhQ4ODg5AQ4NOA8GAAAAAAAAAAAkBFIKCi4RegwLCgoLDQsLCgURdQVUCw04OgsKCwgRbQsGBgEAAAAAAAAAFgwGBRkLAAELBAELAwELBQELAgELAQECNAAAAJcBVAoBQToMCQYAAAAAAAAAAAwICggKCSMESQUKCgEKCEI6DAwKDBF6DA0KBA4NOCYEHAoEDg04OxQ4NAwGBR4HFQwGCwYMCwoFDg04PAQnBgAAAAAAAAAADAcFKQYBAAAAAAAAAAwHCwcMCgoACw0KDBFvCgwRewoMEXwKDBFrCgIKCEIOFAoDCghCDhQLDAoAEXMLCwsKEgI4PQsIBgEAAAAAAAAAFgwIBQULAQELAwELBQELBAELAgECNQEAAIsBIwYAAAAAAAAAAAwEBgAAAAAAAAAADAIKAUE7DAMKAgoDIwQdBQwKAAoBCgJCOxQRIgwFCwQLBRF8FgwECwIGAQAAAAAAAAAWDAIFBwsAAQsBAQsEAjYBAAADAwsAEAACNwEAAAMFCwAQAQsBOAYCOAEAAAMFCwAQAwsBOBICAAEABgAEAAUAAgADAAAABwA/AI8BABF2YWxpZGF0b3Jfd3JhcHBlcsMEoRzrCwYAAAAMAQAIAggQAxgwBEgGBU40B4IB0wEI1QJABpUDCgqfAwYMpQNkDYkEAg+LBAIADgEKARAADAACBAABAAIAAgMMAAMBBAAABQABAAAIAgMAAAYBBAAACwIFAAAPBgcAAgQICQEEAgYJDAEEAgkKCwEEAg8NBwAFBAcEBgQCCAMHCAEBCAABBwgAAQcIAwEIAwABBggAAQMDAwkABwgBAQgCAQcIAgEHCQABCQABBggCCVR4Q29udGV4dAlWYWxpZGF0b3IQVmFsaWRhdG9yV3JhcHBlcglWZXJzaW9uZWQGY3JlYXRlCWNyZWF0ZV92MQdkZXN0cm95BWlubmVyHGxvYWRfdmFsaWRhdG9yX21heWJlX3VwZ3JhZGUObG9hZF92YWx1ZV9tdXQKdHhfY29udGV4dBF1cGdyYWRlX3RvX2xhdGVzdAl2YWxpZGF0b3INdmFsaWRhdG9yX3NldBF2YWxpZGF0b3Jfd3JhcHBlcgd2ZXJzaW9uCXZlcnNpb25lZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAAIBBwgCAAMAAAUGBgEAAAAAAAAACwALATgAEgACAQMAAAUGCgARAwsADwA4AQICAwAABQYNABEDCwATADgCAgMAAAAFCgsALhEEBgEAAAAAAAAAIQQHBQkHACcCBAAAAAUECwAQABEIAgAAAA0AFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXKVQaEc6wsGAAAADAEALQItaAOVAdQFBOkGMgWbB/sGB5YOvB0I0itgBrIsdQqnLb0BDOQuwhENpkAuD9RABABwAUQCGQIaAhsCJwJDAkYCbgJyAngCeQKuAQKvAQBkAGcAagChAQCiAQCmAQAMBAAADQQAAAkEAAAKBAAACwMAAQQHAQAAAgAMAAMBBAEAAQQCDAEAAQYDBwAIBQIACQ4MAgcBBAELDwIADBQHAgEAAAANFQcBAwAOBgQADwcIABAIBAAREQQAEhAMABISAgATEwQAAB0AAQAAHgIDAACgAQEEAABQBQYAAFIHBgAATwcGAABRBwYAAFQIBgAAYAgGAABTCQYAAF8JBgAATQoGAABOCwYAAFUMBgAASw0GAAB6DQYAAEwOBgAAew4GAABWBwYAAJcBDwYAAJUBDwYAAJYBDwYAAJ8BDwYAAJgBDwYAAIEBDwYAAJoBDwYAAIMBDwYAAJsBDwYAAIQBDwYAAJ0BDwYAAIYBDwYAAJwBEAYAAIUBEAYAAJ4BDwYAAIcBDwYAAJkBDwYAAIIBDwYAABcREgAAJBMUAABHExQAAHETFAAALAYUAAAmExQAAKcBFRQAAKgBFRYAAKkBExcAAC8VGAAAMRMUAAAwExQAACkZEgABIF5AAQABOV07AQACQCMkAAMhIgYBAAM6URQBAANiVSIBAAOtAVMUAQADsgFQIgEAA7MBBiIBAAQqXzYBAAQ2NiIBAAUiQAYBAwc7XAYBAApIYAYBDAskJxQAC1wnKAAMHD87AgEADCMGIAIBAAwtP1kCAQAMLkNEAgEADDVCBgIBAAxKQ0kCAQANHEU7AQMNIwZBAQMNNUYGAQMNOEg7AQMNSkcGAQMNYUBBAQMOF1QSAA9jOBQAEBdXEgAQQBIeABBzUhQAEHVSFAARQCkmABFBSgYAEVQyBgARXTUGABFeMgYAEXxLBgARfUsGABF+SwYAEX9LBgARgAFOBgARiAFLBgARiQFLBgARigFLBgARiwFLBgARjAFLBgARjQFLBgARjgFLBgARjwFLBgARkAFLBgARkQFOBgARkgFLBgARkwFLBgARlAFLBgASsAE9PgATFh0tABMXVgYAExhNBgATHx0UABMyNDEAEzM0MQATNDAxABM3OjsAE0AbHAATQh0UABNNNwYAE08sBgATUCoGABNRKwYAE1IrBgATUzMGABNVOQYAE2gdFwATdh0UABOoAToWABOqAToUABOxAS8uAEMfOiE8IUIfTShGH0UfSChKKEwoSyhHHzkhNiE4ITchPVhEH0koPiEzFDIUOyE/WzUhBwoIEgsHAQgKAwMIAAgPBwgMAQgCCAMDAwMDAwMHCAwBCAABCAMQBwgDCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCAwMHCAwAAgcIAwcIDAMHCAMGCBMDAwcIAwMHCAwEBwgDCwgBCAoFBwgMBQcIAwoLCAEICgsFAQMFBwgMAwcIAwgQBwgMAwcIAwYIEwUDCBQFBwsNAgULDgEFAwcIAwoCBggMBAcIAwoCCgIGCAwLBwgDAwMLBwEICgsHAQgKAwMDAwMHCAwBCwcBCAoBBggDAQMCBggDBQEICQEGCwsCCAkFAQsOAQUDCgsIAQgKCwUBAwcIDAIDCBUCCggSBwgMAQgVAQYIFQEIEQIFCw4BBQELDQIJAAkBAQgKAQsHAQkAAQcIDAEIBhcDAwMDAwgGCAADAwELBwEICgMDCwcBCAoIDwMIBggRAwMLDQIFCw4BBQMIFQEIEgEGCAwBBRAFCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCAwMHCAwDBwgVCBIHCAwCBwgVBwgMAwcIFQMHCAwBBgoIEgEIFAMHCBUGCBMCAwcIFQYIFAEBBwgSAwcIEggUAwMHCBUDBggMAgcIFQYIDAIHCBIDAQsIAQkABAcIFQULBwEICgcIDAEGCBADBwgVCBAHCAwCBggVBQEBBAYFBgUFBwsOAQUBBggUAQYFAgYLDQIJAAkBBgkAAQkAAQsOAQkAAwcLDQIJAAkBCQAJAQIHCw0CCQAJAQYJAAEHCQECBgsOAQkABgkAAgcLDgEJAAkAAgcLDgEJAAYJAAEGCw4BCQACCQAJAQIHCBIHCAwCBwgSCgICBwgSBggSAgYIFQYIEgMHCBIKAgoCLAEDAwMDAwMBAQELBwEICgMDAwMDAwMDBAMDAwsHAQgKAwMDCwcBCAoLBwEICgsHAQgKCwcBCAoDAwMLBwEICgQLBwEICgQDAwMDBAMBBwsHAQkAAgcLBwEJAAsHAQkAAQYIEQEGCwcBCQABBwgPAgcLBwEJAAMJBwgVBwsHAQgKBwsHAQgKBwsNAgULDgEFAwMDAwcIDAYHCBELBwEICgsHAQgKCwcBCAoDAwEIBAEGCQEFCwcBCAoDCwcBCAoLCAEICgsHAQgKAQsIAQgKAgcLCAEJAAoLCAEJAAEGCwUBCQABCwUBCQACCwcBCQAHCAwCCQAFA0JhZwdCYWxhbmNlBENvaW4CSUQGT3B0aW9uA1NVSQxTdGFrZVN1YnNpZHkJU3Rha2VkU3VpC1N0b3JhZ2VGdW5kE1N1aVN5c3RlbVN0YXRlSW5uZXIVU3VpU3lzdGVtU3RhdGVJbm5lclYyFFN5c3RlbUVwb2NoSW5mb0V2ZW50EFN5c3RlbVBhcmFtZXRlcnMSU3lzdGVtUGFyYW1ldGVyc1YyBVRhYmxlCVR4Q29udGV4dB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwCVZhbGlkYXRvchVWYWxpZGF0b3JPcGVyYXRpb25DYXAMVmFsaWRhdG9yU2V0BlZlY01hcAZWZWNTZXQRYWN0aXZlX3ZhbGlkYXRvcnMNYWR2YW5jZV9lcG9jaCZhc3NlcnRfbm9fcGVuZGluZ19vcl9hY3RpdmVfZHVwbGljYXRlcwNiYWcHYmFsYW5jZQRjb2luCGNvbnRhaW5zBmNyZWF0ZRhjcmVhdGVfc3lzdGVtX3BhcmFtZXRlcnMaZGVyaXZlX3JlZmVyZW5jZV9nYXNfcHJpY2UMZGVzdHJveV9zb21lDGRlc3Ryb3lfemVybwRlbWl0BWVtcHR5BWVwb2NoEWVwb2NoX2R1cmF0aW9uX21zGGVwb2NoX3N0YXJ0X3RpbWVzdGFtcF9tcwVldmVudAxleHRyYV9maWVsZHMUZXh0cmFjdF9jb2luX2JhbGFuY2UMZnJvbV9iYWxhbmNlB2dlbmVzaXMcZ2VuZXNpc19zeXN0ZW1fc3RhdGVfdmVyc2lvbgNnZXQHZ2V0X211dBBnZXRfcmVwb3J0ZXJzX29mH2dldF9zdG9yYWdlX2Z1bmRfb2JqZWN0X3JlYmF0ZXMeZ2V0X3N0b3JhZ2VfZnVuZF90b3RhbF9iYWxhbmNlGmdldF92YWxpZGF0b3JfbXV0X3dpdGhfY3R4L2dldF92YWxpZGF0b3JfbXV0X3dpdGhfY3R4X2luY2x1ZGluZ19jYW5kaWRhdGVzI2dldF92YWxpZGF0b3JfbXV0X3dpdGhfdmVyaWZpZWRfY2FwBmluc2VydAxpbnRvX2JhbGFuY2UiaXNfYWN0aXZlX3ZhbGlkYXRvcl9ieV9zdWlfYWRkcmVzcwhpc19lbXB0eQdpc19zb21lBGpvaW4Iam9pbl92ZWMcbGVmdG92ZXJfc3RvcmFnZV9mdW5kX2luZmxvdxNtYXhfdmFsaWRhdG9yX2NvdW50E21pbl92YWxpZGF0b3JfY291bnQbbWluX3ZhbGlkYXRvcl9qb2luaW5nX3N0YWtlA25ldzNuZXdfdW52ZXJpZmllZF92YWxpZGF0b3Jfb3BlcmF0aW9uX2NhcF9hbmRfdHJhbnNmZXIabmV4dF9lcG9jaF92YWxpZGF0b3JfY291bnQGb2JqZWN0Bm9wdGlvbgpwYXJhbWV0ZXJzA3BheRBwcm90b2NvbF92ZXJzaW9uD3B1YmxpY190cmFuc2ZlchNyZWZlcmVuY2VfZ2FzX3ByaWNlBnJlbW92ZRByZXBvcnRfdmFsaWRhdG9yFXJlcG9ydF92YWxpZGF0b3JfaW1wbBFyZXF1ZXN0X2FkZF9zdGFrZRpyZXF1ZXN0X2FkZF9zdGFrZV9tdWxfY29pbhVyZXF1ZXN0X2FkZF92YWxpZGF0b3IfcmVxdWVzdF9hZGRfdmFsaWRhdG9yX2NhbmRpZGF0ZRhyZXF1ZXN0X3JlbW92ZV92YWxpZGF0b3IicmVxdWVzdF9yZW1vdmVfdmFsaWRhdG9yX2NhbmRpZGF0ZRtyZXF1ZXN0X3NldF9jb21taXNzaW9uX3JhdGUVcmVxdWVzdF9zZXRfZ2FzX3ByaWNlFnJlcXVlc3Rfd2l0aGRyYXdfc3Rha2UUcm90YXRlX29wZXJhdGlvbl9jYXAJc2FmZV9tb2RlHXNhZmVfbW9kZV9jb21wdXRhdGlvbl9yZXdhcmRzJHNhZmVfbW9kZV9ub25fcmVmdW5kYWJsZV9zdG9yYWdlX2ZlZRlzYWZlX21vZGVfc3RvcmFnZV9yZWJhdGVzGXNhZmVfbW9kZV9zdG9yYWdlX3Jld2FyZHMGc2VuZGVyHXNldF9jYW5kaWRhdGVfY29tbWlzc2lvbl9yYXRlF3NldF9jYW5kaWRhdGVfZ2FzX3ByaWNlJ3NldF9jYW5kaWRhdGVfdmFsaWRhdG9yX2NvbW1pc3Npb25fcmF0ZSFzZXRfY2FuZGlkYXRlX3ZhbGlkYXRvcl9nYXNfcHJpY2UJc2luZ2xldG9uBXNwbGl0FnN0YWtlX2FjdGl2YXRpb25fZXBvY2gNc3Rha2Vfc3Vic2lkeRRzdGFrZV9zdWJzaWR5X2Ftb3VudBlzdGFrZV9zdWJzaWR5X3N0YXJ0X2Vwb2NoDHN0YWtpbmdfcG9vbBVzdGFraW5nX3Bvb2xfbWFwcGluZ3MOc3RvcmFnZV9jaGFyZ2UMc3RvcmFnZV9mdW5kFHN0b3JhZ2VfZnVuZF9iYWxhbmNlGXN0b3JhZ2VfZnVuZF9yZWludmVzdG1lbnQOc3RvcmFnZV9yZWJhdGUDc3VpCnN1aV9zeXN0ZW0Wc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchRzeXN0ZW1fc3RhdGVfdmVyc2lvbgV0YWJsZQ10b3RhbF9iYWxhbmNlDnRvdGFsX2dhc19mZWVzHHRvdGFsX29iamVjdF9zdG9yYWdlX3JlYmF0ZXMLdG90YWxfc3Rha2UfdG90YWxfc3Rha2VfcmV3YXJkc19kaXN0cmlidXRlZAh0cmFuc2Zlcgp0eF9jb250ZXh0FXVuZG9fcmVwb3J0X3ZhbGlkYXRvchp1bmRvX3JlcG9ydF92YWxpZGF0b3JfaW1wbCB1cGRhdGVfY2FuZGlkYXRlX25ldHdvcmtfYWRkcmVzcx91cGRhdGVfY2FuZGlkYXRlX25ldHdvcmtfcHVia2V5HHVwZGF0ZV9jYW5kaWRhdGVfcDJwX2FkZHJlc3MgdXBkYXRlX2NhbmRpZGF0ZV9wcmltYXJ5X2FkZHJlc3MgdXBkYXRlX2NhbmRpZGF0ZV9wcm90b2NvbF9wdWJrZXkqdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfbmV0d29ya19hZGRyZXNzKXVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX25ldHdvcmtfcHVia2V5JnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3AycF9hZGRyZXNzKnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3ByaW1hcnlfYWRkcmVzcyp1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wcm90b2NvbF9wdWJrZXkpdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3Jfd29ya2VyX2FkZHJlc3ModXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3Jfd29ya2VyX3B1YmtleR91cGRhdGVfY2FuZGlkYXRlX3dvcmtlcl9hZGRyZXNzHnVwZGF0ZV9jYW5kaWRhdGVfd29ya2VyX3B1YmtleRJ1cGRhdGVfZGVzY3JpcHRpb24QdXBkYXRlX2ltYWdlX3VybAt1cGRhdGVfbmFtZSF1cGRhdGVfbmV4dF9lcG9jaF9uZXR3b3JrX2FkZHJlc3MgdXBkYXRlX25leHRfZXBvY2hfbmV0d29ya19wdWJrZXkddXBkYXRlX25leHRfZXBvY2hfcDJwX2FkZHJlc3MhdXBkYXRlX25leHRfZXBvY2hfcHJpbWFyeV9hZGRyZXNzIXVwZGF0ZV9uZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleSB1cGRhdGVfbmV4dF9lcG9jaF93b3JrZXJfYWRkcmVzcx91cGRhdGVfbmV4dF9lcG9jaF93b3JrZXJfcHVia2V5EnVwZGF0ZV9wcm9qZWN0X3VybBx1cGRhdGVfdmFsaWRhdG9yX2Rlc2NyaXB0aW9uGnVwZGF0ZV92YWxpZGF0b3JfaW1hZ2VfdXJsFXVwZGF0ZV92YWxpZGF0b3JfbmFtZSt1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfbmV0d29ya19hZGRyZXNzKnVwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9uZXR3b3JrX3B1YmtleSd1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfcDJwX2FkZHJlc3MrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3ByaW1hcnlfYWRkcmVzcyt1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfcHJvdG9jb2xfcHVia2V5KnVwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF93b3JrZXJfYWRkcmVzcyl1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfd29ya2VyX3B1YmtleRx1cGRhdGVfdmFsaWRhdG9yX3Byb2plY3RfdXJsCHYxX3RvX3YyCXZhbGlkYXRvcg12YWxpZGF0b3JfY2FwIHZhbGlkYXRvcl9sb3dfc3Rha2VfZ3JhY2VfcGVyaW9kHXZhbGlkYXRvcl9sb3dfc3Rha2VfdGhyZXNob2xkGHZhbGlkYXRvcl9yZXBvcnRfcmVjb3Jkcw12YWxpZGF0b3Jfc2V0FnZhbGlkYXRvcl9zdGFrZV9hbW91bnQZdmFsaWRhdG9yX3N0YWtpbmdfcG9vbF9pZB92YWxpZGF0b3Jfc3Rha2luZ19wb29sX21hcHBpbmdzHHZhbGlkYXRvcl90b3RhbF9zdGFrZV9hbW91bnQidmFsaWRhdG9yX3ZlcnlfbG93X3N0YWtlX3RocmVzaG9sZAp2YWxpZGF0b3JzBXZhbHVlB3ZlY19tYXAHdmVjX3NldB52ZXJpZmllZF9vcGVyYXRpb25fY2FwX2FkZHJlc3MKdmVyaWZ5X2NhcAx3aXRoZHJhd19hbGwEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIBAQIBAgIBAwMIAQAAAAAAAAADCAAAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAMIBgAAAAAAAAADCAcAAAAAAAAAAwgIAAAAAAAAAAQQECcAAAAAAAAAAAAAAAAAAAACCCUDZgM9Az8DpAEDqwEDowEDKAgGAQIJJQNmAz4DPQM/A6QBA6sBA6MBAygIBgICECQDRwNxA6wBCBVqCBFFCABJA6UBCw0CBQsOAQVkCA9XAVsLBwEIClgLBwEICloDWQMmAygIBgMCECQDRwNxA6wBCBVqCBFFCAFJA6UBCw0CBQsOAQVkCA9XAVsLBwEIClgLBwEICloDWQMmAygIBgQCDCQDRwNJA3YDbANpA20DawNlA3QDdwM8AwADAAAaGwsACgYRdAwIDggRbwwHBgAAAAAAAAAACwIRKQsICwERUQsECwc4AAsFCTgBOAEGAAAAAAAAAAAGAAAAAAAAAAALAwsGETQSAgIBAwAABgsLAAsBCwILAwsECwULBgsHETQSAAICAwAAJTcLABMCDBEMAwwMDA0MCwwODAoMDwwVDAkMBwwSDBcBDAgMAQsHEwAMBgwTDBYMFAwFDAQMEAwCCwELCAYCAAAAAAAAAAsXCxILAgsQBgQAAAAAAAAACwQLBQsUCxYLEwsGEgELCQsVCw8LCgsOCwsLDQsMCwMLERIDAgMDAAAmGgoPLhFBCwELAgsDCwQLBQsGCwcLCAsJCwoLCwsMCw0LDgoPEVQMEAsADwALEAsPEXgCBAMAAAYFCwAPAAsBEXoCBQMAAAYZCgAQABF1CgAQARACFCMECgUQCwABCwEBBwMnCgAPAAsAEAEQAxQLARF3AgYDAAAGHwoAEAARbEEmCgAQARAEFCYEGgoAEAARdQoAEAEQBBQkBBQFGgsAAQsBAQcDJwsADwALARF5AgcDAAAuDwoADwALAQcBEYEBDAMLAA8ADgMJEXILAwsCEVYCCAMAAC4PCgAPAAsBBwIRgQEMAwsADwAOAwgRcgsDCwIRWAIJAwAABgcLAA8ACwELAi4RewIKAwAABggLAA8ACwIuEXELARFXAgsDAAAGCAsADwALAgsBOAILAxF2AgwDAAASDAsBCwIKBBExDAULAA8ACwMLBQsEEXYCDQMAAAYUDgERTwoCLhFAJQQIBQ4LAAELAgEHCScLAA8ACwELAhF8Ag4DAAAGFgoAEAAKAhFzBAYFDAsAAQsBAQcEJwoADwALAQcAEYEBCwILAA8FERACDwMAAAYKCgAPAAsBBwARgQELAgsADwUREQIQAAAAPC4OABFrFAwFCgUKASIECQUNCwIBBwYnCgIOAQwDLgsDOAMgBBsLAgsBCwU4BDgFBS0LAg4BOAYMBgoGDgUMBC4LBDgHIAQrCwYLBTgIBS0LBgECEQAAADwyCgIOAQwDLgsDOAMECAUMCwIBBwcnCgIOATgGDAYOABFrFAwFCgYOBQwELgsEOAcEHAUiCwIBCwYBBwcnCgYOBTgJCwYuOAoELwsCDgE4CwEBBTELAgECEgMAAAYICwAPAAoBLhFxCwERVQITAwAABgcLAA8ACwIRcQsBEWICFAMAAAYHCwAPAAsCEXELARFgAhUDAAAGBwsADwALAhFxCwERYQIWAwAABgcLAA8ACwIRcQsBEWoCFwMAAEwQCgAPAAsCEXAMAwoDCwERYwsDLgwECwAQAAsEEW4CGAMAAAYHCwAPAAsCEXELARFZAhkDAABMEAoADwALAhFwDAMKAwsBEWULAy4MBAsAEAALBBFuAhoDAAAGBwsADwALAhFxCwERWwIbAwAABgcLAA8ACwIRcAsBEWYCHAMAAAYHCwAPAAsCEXELARFcAh0DAAAGBwsADwALAhFwCwERaAIeAwAABgcLAA8ACwIRcQsBEV4CHwMAAEwRCgAPAAsDEXAMBAoECwELAhFnCwQuDAULABAACwURbgIgAwAABggLAA8ACwMRcQsBCwIRXQIhAwAATBAKAA8ACwIRcAwDCgMLARFpCwMuDAQLABAACwQRbgIiAwAABgcLAA8ACwIRcQsBEV8CIwMAAEwQCgAPAAsCEXAMAwoDCwERZAsDLgwECwAQAAsEEW4CJAMAAAYHCwAPAAsCEXELARFaAiUDAABP0AIKABAGFAwlCgkKAA8GFQcMNAwcCgcKHCUEFAoICxwlDAsFFgkMCwsLBBkFHwsAAQsKAQcIJwoADwc4DAwoDQMLKDgNAQoADwg4DAwnDQQLJzgNAQsFCgAQCRQWDAUGAAAAAAAAAAAKAA8JFQsGCgAQChQWDAYGAAAAAAAAAAAKAA8KFQoAEAARfgw2CgAQCxFSDCwKLAs2Fgw0DgM4DgwrDgQ4DgwdCgouEUAKABABEAwUJgRoCwkLJQoAEAEQDRQWJgwUBWoJDBQLFARxCgAPDhFODBUFczgBDBULFQwpDik4DgwqDQQLKTgNAQs0NQw1Ch01DB4LLDULHhgLNRoMMA0ECjA0OA8MLwswCwc1GAcMGgwuDS8KLjQ4DwwtCgAQDxQGAQAAAAAAAAAWCgAPDxULAQoAEA8UIQSpAQWvAQsAAQsKAQcLJw4EOA4MIA4vOA4MMgoADwANBA0vCgAPBQsICgAQARAQFAoAEAEQERQKABABEBIUCwoRbQoAEAARfgwkDgQ4DgwfDi84DgwxCyALHxcMIQsyCzEXDDMLAgoADxMVCgAQABFvCgAPFBULLwwiDSILBDgNAQ4iOA4MIwoADwsLAwstCyIKBQsGEVAMJgoAEA8UDBYKABATFAwXCgAQFBQMGAskDBkLKwwaCy40DBsLBQwMCgAQCxFSDA0LKgwOCx0MDwshCzMWDBALIwwRCxYLFwsYCxkLGwsaCwwLDQsOCw8LEAsREgQ4EAkKAA8VFQoAEAkUBgAAAAAAAAAAIQS6AgoAEAc4DgYAAAAAAAAAACEMEgW8AgkMEgsSBMUCCwAQCDgOBgAAAAAAAAAAIQwTBckCCwABCQwTCxMEzAIFzgIHCicLJgImAwAABgQLABAPFAInAwAABgQLABATFAIoAwAABgQLABAWFAIpAwAABgIHAwIqAwAABgQLABAGFAIrAwAABgULABAACwERgAECLAMAAAYFCwAQAAsBEX8CLQMAAAYECwAQABF9Ai4DAAAYEgoAEAUOATgDBAwLABAFDgE4ERQMAgUQCwABOBIMAgsCAi8DAAAGBAsAEAsRUgIwAwAABgQLABALEVMCMQAAAFotDQBFWwwGDQYLADgTCwY4AgwHDgE4FAQnCwE4FQwEDQcLBDgPDAUOBzgOBgAAAAAAAAAAJAQgCwcKAjgWCwIuEUE4FwUkCwIBCwc4GAsFDAMFKwsCAQsHDAMLAwIDAwMFAQMBBAECAwcDDgMKAwsDDAMNAwQBAQEAAwgDAAEFAQYBBwMBAwYDCQMCACsAbwAdDXZhbGlkYXRvcl9jYXAfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9jYXAVVmFsaWRhdG9yT3BlcmF0aW9uQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMc3Rha2luZ19wb29sC1N0YWtpbmdQb29sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMc3Rha2luZ19wb29sFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbAlTdGFrZWRTdWkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwl2YWxpZGF0b3IRVmFsaWRhdG9yTWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwl2YWxpZGF0b3IJVmFsaWRhdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJdmFsaWRhdG9yE1N0YWtpbmdSZXF1ZXN0RXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwl2YWxpZGF0b3IVVW5zdGFraW5nUmVxdWVzdEV2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMdm90aW5nX3Bvd2VyD1ZvdGluZ1Bvd2VySW5mbwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHZvdGluZ19wb3dlchFWb3RpbmdQb3dlckluZm9WMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEXZhbGlkYXRvcl93cmFwcGVyEFZhbGlkYXRvcldyYXBwZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0DFZhbGlkYXRvclNldAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9zZXQXVmFsaWRhdG9yRXBvY2hJbmZvRXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0GVZhbGlkYXRvckVwb2NoSW5mb0V2ZW50VjIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0ElZhbGlkYXRvckpvaW5FdmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9zZXQTVmFsaWRhdG9yTGVhdmVFdmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0b3JhZ2VfZnVuZAtTdG9yYWdlRnVuZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXN0YWtlX3N1YnNpZHkMU3Rha2VTdWJzaWR5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchBTeXN0ZW1QYXJhbWV0ZXJzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchJTeXN0ZW1QYXJhbWV0ZXJzVjIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxZzdWlfc3lzdGVtX3N0YXRlX2lubmVyE1N1aVN5c3RlbVN0YXRlSW5uZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxZzdWlfc3lzdGVtX3N0YXRlX2lubmVyFVN1aVN5c3RlbVN0YXRlSW5uZXJWMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIUU3lzdGVtRXBvY2hJbmZvRXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwpzdWlfc3lzdGVtDlN1aVN5c3RlbVN0YXRlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMHZ2VuZXNpcxhHZW5lc2lzVmFsaWRhdG9yTWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwdnZW5lc2lzFkdlbmVzaXNDaGFpblBhcmFtZXRlcnMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwdnZW5lc2lzGVRva2VuRGlzdHJpYnV0aW9uU2NoZWR1bGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwdnZW5lc2lzD1Rva2VuQWxsb2NhdGlvbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwpzdWlfc3lzdGVtDlN1aVN5c3RlbVN0YXRlAAAAAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFY2xvY2sFQ2xvY2sAAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAACAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pAQAAAAAAAAAEBGNsb2KTSaEc6wsGAAAADQEAIwIjdgOZAbkEBNIFtgEFiAflCQftEKcOCJQfYAb0H50CCpEisAELwSMIDMkjvyQNiEgsDrRIHAArADMANABaAWcBhAECGgIsAi0CPgJSAmUCegJ9AoIBAoMBAA4HAAAMBwIAAQABAAoHAgABAAEACwcCAAEAAQAJBgAAEQQAAA0IAgABAAEBBAQBBAACAAwAAgUMAQABBAgHAQAABRMHAAYBBAEAAQcCCAAIAwwBAAEKBwwCBwAEAQsGBwALFAQADA8CAA0QDAIHAQQBDxICAAA6AAEAAC8CAwAAMQQBAgAAADAFAQIAAAA3BgECAAAAOAcBAgAAAIkBCAkCAAAAiwEICgIAAAB7CwwCAAAAfA0MAgAAAFkODwIAAABYDg8CAAAAVxAPAgAAAGwREgIAAABLExQCAAAAaxUWAgAAAGkUFwAAPRgBAgAAACoZAQIAAAB3GhsCAAAAKRwBAgAAACIdAQIAAABTHh8CAAAAFh4gAgAAAEchIgIAAABGISICAAAARSMUAgAAAEgkJQIAAAElVDoBBAEmVDoBBAEoRkcBBAFAVBQBBAFBVE0BBAFMWxQBBAFPRBcBBAFbREUBBAFcREUBBAFgAjABBAFkVEUBBAFuVEUBBAF2RioBBAIVYRQBAAIWYUUBAAI1WjQBAAI2TDQBAAJKPAEBAAJUWgEBAAJdAgMAAmACMwEAAoYBTAEBAAKKAT0JAQACjAE9CQEAAztFTQADXkUUAANfRU0ABCRJOgEABFBJFwEABUQBKwEABlFPFAEABnlONAEABogBQRQBAAaNAQE0AQAHgAFAFAAIQkIJAQAITQk0AQAIUVgBAQAIiAE5FAEACTwqAQEDChlISQIHBAokSksCBwQKJ1NSAgcECi5KFwIHBAo5KAECBwQKQ0hJAgcECk9IFwIHBApgAigCBwQKYUpJAgcECnBcAQIHBAp1UywCBwQLSTo7AQgLYAItAAuFAS4vAA0XXwECBwQNJF5LAgcEDSdRUgIHBA0uXhcCBwQNYAIyAgcEDngqAQEISCc5KjksJQBWMTAqMCw9Kj0sVzZDN0I4QDgCNU8DQCotKkAsLSwyKjMsQiwNNQo1PCo/Kj8sIgAkAB4ASSc3FEonRScxKiwqOyo6KjssQ1BMJzgUVDFORU4nRicmACgAIAARNSMAMSwsLDosJwALNUEqQioMNUEsLiwuKksnIQBNJ0NdVTFLRVIxTUUpLCssPCwrKg41Q2JHRUVFEzUcAEcnSkVERVMxSUUdAExFKioqLB8AGjUBCAUAAQcIFAEICAYDAwMDCwwBCBIHCBQEAwMLDgEIEgcIFAMHCwYCCQAJAQsOAQkABggIAwcLBgIJAAkBCw4BCQEGCAgEBwsGAgkACQEDBggIBwgUAQsOAQkAAQsOAQkBBgcLBgIJAAkBAwsOAQkACw4BCQEGCA0HCBQDCw4BCQALDgEJAQMFBwsGAgkACQEDBggNCw4BCQEHCBQFBwsGAgkACQEDAwMLDAEJAQILDAEJAAsMAQkBBAcLBgIJAAkBAwMLDAEJAAcHCwYCCQAJAQMBCw4BCQALDgEJAQYIDQcIFAILDgEJAAsOAQkBBwcLBgIJAAkBAwMBAwYICAcIFAEDCQcLBgIJAAkBAwMBAwIGCA0GCAgHCBQEAwMBAwEBAggQBggEAwcLBgIJAAkBAwYICAUHCwcBCAUHCw8CAwMDAwgQAQgEAgcLBgIJAAkBBggIAwcLBgIJAAkBCgMGCAgCBgsGAgkACQEGCAgBCggEBAMDAwMEBgsGAgkACQEDAwYIDQIKAwoDAwYLBwEIBQMDAwYLBgIJAAkBAwYICAEGCAQBCw8CAwgEAgMIBAELDwIJAAkBBAgLCBAIEQgLAQkAAQgLAQkBAQgRAQYIEQEGCBABCwcBCQACCBALDwIDAwELEwIJAAkBAQsJAQkAAQsMAQkAAgkACQEBCwYCCQAJAQEIAAEIEgEGCw4BCQABBgkAAQgQAwcLCQEJAAgQCwwBCQAEBwsJAQkAAwYICAcIFAQDCw4BCQALDgEJAQMDCwwBCQALDAEJAQMBBggNAQYLDAEJAAILDAEJAAcIFBoBAwEDAwcLBwEIBQsMAQkAAwMLDAEJAAMGCAQHCAQDAwYLCgEDAwMLDAEJAQEDCwwBCQADAwcIBQMBBgsHAQkAAgMDAgcLBwEJAAMBBwkAAQYLDwIJAAkBAQYLCgEJAAIGCw8CCQAJAQkAAQYJAQMHCwkBCQAIEAMCAQMCBwsMAQkAAwIHCwwBCQALDAEJAAELAwIJAAkBAgcLEwIJAAkBCQABBwkBAgcLDwIJAAkBCQACBgsHAQkAAxoBAwEDAwcLBwEIBQsMAQkAAwMLDAEJAAMGCAQHCAQDBgsKAQMDAwgQCwwBCQEBAwMLDAEJAAMHCAUDGwEDAQMDBwsHAQgFCwwBCQADAwsMAQkBAwYIBAcIBAMDBgsKAQMDAwgQCwwBCQEBAwMLDAEJAQMHCAUDAwsMAQkACwwBCQELDAEJAQIHCw4BCQALDgEJAAcDBwsHAQgFCAQDAwMIEAMHCwkBCQAGCAgDAwcLBwEJAAMJAAMHCw8CCQAJAQkACQEBCwECCQAJAQIGCxMCCQAJAQkAAwcLEwIJAAkBCQAJAQsLDAEJAAsMAQkACwwBCQADAwsMAQkBCwwBCQELDAEJAQMDCBACBgsJAQkACBABCwICCQAJAQsDAwYLBwEIBQcLBwEIBQMBCAQDAwgQBwsPAgMDAwMHCAUIBA0DBwsHAQgFAwMBBwsHAQgFCAQDAwgQAwgQBwsPAgMDEgYLBwEIBQMDBgsHAQgFBwsHAQgFAwMBAwMDCAQDCBADAwgQBwsPAgMDBwYIBQoIBAYIBAYLCgEDAwgQBgsPAgMDBQMDAwMIEAYDCgMDAwMKAwQDBggEBgsKAQMGCw8CAwgEAwYLBwEIBQMIEApBY2NvdW50Q2FwB0JhbGFuY2UFQ2xvY2sEQ29pbgtDcml0Yml0VHJlZQlDdXN0b2RpYW4CSUQLTGlua2VkVGFibGUGT3B0aW9uBU9yZGVyDU9yZGVyQ2FuY2VsZWQLT3JkZXJGaWxsZWQLT3JkZXJQbGFjZWQEUG9vbAtQb29sQ3JlYXRlZANTVUkFVGFibGUJVGlja0xldmVsCVR4Q29udGV4dAhUeXBlTmFtZQNVSUQZYWNjb3VudF9hdmFpbGFibGVfYmFsYW5jZQ9hY2NvdW50X2JhbGFuY2UDYWRkBGFza3MEYmFjawdiYWxhbmNlCmJhc2VfYXNzZXQcYmFzZV9hc3NldF9xdWFudGl0eV9jYW5jZWxlZBpiYXNlX2Fzc2V0X3F1YW50aXR5X2ZpbGxlZBpiYXNlX2Fzc2V0X3F1YW50aXR5X3BsYWNlZB1iYXNlX2Fzc2V0X3F1YW50aXR5X3JlbWFpbmluZxdiYXNlX2Fzc2V0X3RyYWRpbmdfZmVlcw5iYXNlX2N1c3RvZGlhbhJiYXRjaF9jYW5jZWxfb3JkZXIEYmlkcwZib3Jyb3cUYm9ycm93X2xlYWZfYnlfaW5kZXgSYm9ycm93X2xlYWZfYnlfa2V5CmJvcnJvd19tdXQYYm9ycm93X211dF9sZWFmX2J5X2luZGV4EWNhbmNlbF9hbGxfb3JkZXJzDGNhbmNlbF9vcmRlcgRjbG9iBWNsb2NrBGNvaW4IY29udGFpbnMOY3JlYXRlX2FjY291bnQLY3JlYXRlX3Bvb2wMY3JlYXRlX3Bvb2xfDGNyZWF0aW9uX2ZlZQdjcml0Yml0CWN1c3RvZGlhbh9kZWNyZWFzZV91c2VyX2F2YWlsYWJsZV9iYWxhbmNlHGRlY3JlYXNlX3VzZXJfbG9ja2VkX2JhbGFuY2UMZGVwb3NpdF9iYXNlDWRlcG9zaXRfcXVvdGUNZGVzdHJveV9lbXB0eRNkZXN0cm95X2VtcHR5X2xldmVsCWRpdl9yb3VuZARlbWl0E2VtaXRfb3JkZXJfY2FuY2VsZWQFZXZlbnQQZXhwaXJlX3RpbWVzdGFtcBBmaW5kX2Nsb3Nlc3Rfa2V5CWZpbmRfbGVhZgxmcm9tX2JhbGFuY2UFZnJvbnQDZ2V0FmdldF9sZXZlbDJfYm9va19zdGF0dXMfZ2V0X2xldmVsMl9ib29rX3N0YXR1c19hc2tfc2lkZR9nZXRfbGV2ZWwyX2Jvb2tfc3RhdHVzX2JpZF9zaWRlEGdldF9vcmRlcl9zdGF0dXMCaWQfaW5jcmVhc2VfdXNlcl9hdmFpbGFibGVfYmFsYW5jZRJpbmplY3RfbGltaXRfb3JkZXILaW5zZXJ0X2xlYWYMaW50b19iYWxhbmNlBmlzX2JpZAhpc19lbXB0eQdpc19ub25lBGpvaW4MbGlua2VkX3RhYmxlEGxpc3Rfb3Blbl9vcmRlcnMMbG9ja19iYWxhbmNlCGxvdF9zaXplEW1ha2VyX3JlYmF0ZV9yYXRlCW1hdGNoX2FzawltYXRjaF9iaWQdbWF0Y2hfYmlkX3dpdGhfcXVvdGVfcXVhbnRpdHkEbWF0aAhtYXhfbGVhZghtaW5fbGVhZhBtaW50X2FjY291bnRfY2FwA211bAltdWxfcm91bmQDbmV3BG5leHQRbmV4dF9hc2tfb3JkZXJfaWQRbmV4dF9iaWRfb3JkZXJfaWQJbmV4dF9sZWFmBm9iamVjdAtvcGVuX29yZGVycwZvcHRpb24Ib3JkZXJfaWQMb3JkZXJfaXNfYmlkBW93bmVyEXBsYWNlX2xpbWl0X29yZGVyEnBsYWNlX21hcmtldF9vcmRlcgdwb29sX2lkDXByZXZpb3VzX2xlYWYFcHJpY2UJcHVzaF9iYWNrCHF1YW50aXR5C3F1b3RlX2Fzc2V0GHF1b3RlX2Fzc2V0X3RyYWRpbmdfZmVlcw9xdW90ZV9jdXN0b2RpYW4GcmVtb3ZlFHJlbW92ZV9sZWFmX2J5X2luZGV4DHJlbW92ZV9vcmRlcgxzaGFyZV9vYmplY3QFc3BsaXQDc3VpGXN3YXBfZXhhY3RfYmFzZV9mb3JfcXVvdGUZc3dhcF9leGFjdF9xdW90ZV9mb3JfYmFzZQV0YWJsZQ50YWtlcl9mZWVfcmF0ZQl0aWNrX3NpemUMdGltZXN0YW1wX21zDnRvdGFsX3F1YW50aXR5CHRyYW5zZmVyCnR4X2NvbnRleHQJdHlwZV9uYW1lDHVpZF9hc19pbm5lcg51bmxvY2tfYmFsYW5jZQ91c3Jfb3Blbl9vcmRlcnMFdmFsdWUNd2l0aGRyYXdfYmFzZRN3aXRoZHJhd19iYXNlX2Fzc2V0DndpdGhkcmF3X3F1b3RlFHdpdGhkcmF3X3F1b3RlX2Fzc2V0BHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAMIBgAAAAAAAAADCAcAAAAAAAAAAwgIAAAAAAAAAAMICQAAAAAAAAADCAoAAAAAAAAAAwgLAAAAAAAAAAMIDAAAAAAAAAADCA0AAAAAAAAAAwgPAAAAAAAAAAMIEAAAAAAAAAADCBEAAAAAAAAAAwgSAAAAAAAAAAMIEwAAAAAAAAADCBQAAAAAAAAAAwgVAAAAAAAAAAMIFgAAAAAAAAACAQQCAQACAQECAQICAQMDCAAAAAAAAAAAAwgAAAAAAAAAgAMIQEtMAAAAAAADCKAlJgAAAAAAAwgA6HZIFwAAAAMIAMqaOwAAAAAAAgdtCBAbCAtyCAt+A1YDfwNVAwECBm0IEGgDTgFqCBAeA28DAgIGbQgQaANOAWoIEBwDbwMDAghtCBBoA04BaggQgQEDHQMfA28DBAIGaANvA3EDTgFqCBA/AwUCAm8DZgsPAgMIBAYCD0kIESMLBwEIBRgLBwEIBWMDYgOHAQsTAggQCw8CAwN+A1YDfwNVAyELCQEJAHQLCQEJATILDAEIEiALDAEJAHMLDAEJAQY1AzUBNQI1AAAAACYHCwATBQwBAQsBOAACAQEAAAEDCwARLwICAAAAKT04AQwGOAIMCQoGCgkiBAkFDQsFAQcPJwoACgEmBBIFFgsFAQcBJwoFEVAMCA4IEVEUDAcLCAoFOAMKBTgDBxoHGwoFOAQKAAoBCgIKAwoFOAULBTgGCwQ4BzgIOQA4CQsHCwYLCQsACwELAgsDEgA4CgIDAQAAARMOAjgLBx4hBAYFCgsDAQcTJwccBx0LAAsBCwI4DAsDOA0CBAEAAAEICwA2AAsCOA4LATgPOBACBQEAAAEICwA2AQsCOA4LATgROBICBgEAAAEHCwA2AAsBCwILAzgTAgcBAAABBwsANgELAQsCCwM4FAIIAQAAPhYOAzgVDAYLAAsBCQsCCwMLBAsFOBYMCAwHDgg4FQwJCwcLCAsJCwYXAgkBAAA/FQsACwEHGwsCET4LAzgROBcMBgwFDgU4GAwHCwUKBDgZCwYLBDgaCwcCCgAAAEOtAgsBDBs4BwwLCwQMFwoANgIMCgoKLjgbBBQLAAELCgELCwsXAgoKLjgcDBwMHgoKLjgbIAQkBR8KHgoCJQwFBSYJDAULBQSqAgoKChw4HQwdCh0QAzgeOB8UDBYKHRADOCAgBIgCBTgKHRADChY4IQwQChAQBBQMDwkMGAoQEAUUCgMlBFUIDBgKADYAChAQBhQKEBAEFDgiBcsBCg8KEBAHFBE2DBIEYAsSBgEAAAAAAAAAFgwSChsKEiYEZwsSDAYFaQobDAYLBgwNCg0KEBAHFBE0DAwEdgsMBgEAAAAAAAAAFgwMCgwKADcDFBE1DBMKDAoANwQUETYMGQSHAQsZBgEAAAAAAAAAFgwZCw8KDBcMDwsbCg0XDBsKADYAChAQBhQKDDgjDA4NDgsZOCQMGgoANgAKEBAGFA0aCxM4JDgQCgA2BQsaOCUBDQsLDjglAQoANgEKEBAGFA0XCw04JjgSCgA3BhFRFAoQEAwUCQoQEAYUChAQBBQLDAoPChAQBxQ5ATgnCxgE0AEIDAcF1AEKDwYAAAAAAAAAACEMBwsHBPcBChYMFQodEAMKFjgoDBQKFDgpIATmAQsUOB8UDBYF6AELFAEKADYHCxAQBhQ4KgoVOCsBCh0PAwsVOCwBBYICCxABCh0PAwoWOC0MEQsPCxEPBBUKGwYAAAAAAAAAACEEhwIFiAIFMgsdEAM4IASgAgoKCx4MCC4LCDguAQweCgoLHDgvEQAKCgoeDAkuCwk4MAwcAQobBgAAAAAAAAAAIQSpAgsAAQsKAQWqAgUZCwsLFwILAAAAVaICCgA3BhFRFAwWCwEMGTgHDAsLBAwXCgA2AgwKCgouOBsEGQsAAQsKAQsLCxcCCgouOBwMHAweCgouOBsgBCkFJAoeCgIlDAUFKwkMBQsFBJ8CCgoKHDgdDB0KHRADOB44HxQMFQodEAM4ICAE/QEFPQodEAMKFTghDBAKEBAEFAwPCQwYChAQBRQKAyUEXQgMGAoANgAKEBAGFAoQEAQUOCIKFgoQODEFwAEKGQoPJgRkCg8MBgVmChkMBgsGDAwKDAoQEAcUETUMDQoMCgA3AxQRNQwSCgwKADcEFBE2DBoEfwsaBgEAAAAAAAAAFgwaCw8KDBcMDwsZCgwXDBkKADYAChAQBhQKDDgjDA4NDgsaOCQMGwoANgAKEBAGFA0bCxI4JDgQCgA2BQsbOCUBDQsLDjglAQoANgEKEBAGFA0XCw04JjgSChYKEBAMFAkKEBAGFAoQEAQUCwwKDwoQEAcUOQE4JwsYBMUBCAwHBckBCg8GAAAAAAAAAAAhDAcLBwTsAQoVDBQKHRADChU4KAwTChM4KSAE2wELEzgfFAwVBd0BCxMBCgA2BwsQEAYUOCoKFDgrAQodDwMLFDgsAQX3AQsQAQodDwMKFTgtDBELDwsRDwQVChkGAAAAAAAAAAAhBPwBBf0BBTcLHRADOCAElQIKCgseDAguCwg4LgEMHgoKCxw4LxEACgoKHgwJLgsJODAMHAEKGQYAAAAAAAAAACEEngILAAELCgEFnwIFHgsLCxcCDAAAAFaqAgoANwYRURQMFgsDDAo4CAwXCgA2CAwJCgkuOBsEFwsAAQsJAQsKCxcCCgkuODIMHAweCgkuOBsgBCcFIgoeCgEmDAQFKQkMBAsEBKcCCgkKHDgdDB0KHRADOB44HxQMFQodEAM4ICAEhAIFOwodEAMKFTghDA8KDxAEFAwOCQwYCg8QBRQKAiUEYQgMGAoPEAQUCg8QBxQRNQwRCgA2AQoPEAYUCxE4MwoWCg84MQXGAQ4KOBgMGQoZCg4mBGsKDgwFBW0LGQwFCwUMCwoLCg8QBxQRNQwMCgwKADcDFBE1DBIKDAoANwQUETYMGgSGAQsaBgEAAAAAAAAAFgwaCw4KCxcMDgoANgEKDxAGFAsMODQMDQ0NCxo4JgwbCgA2AQoPEAYUDRsLEjgmOBIKADYJCxs4NQENFwsNODUBCgA2AAoPEAYUDQoKCzgkOBAKADcGEVEUCg8QDBQICg8QBhQKDxAEFAsLCg4KDxAHFDkBOCcLGATLAQgMBgXPAQoOBgAAAAAAAAAAIQwGCwYE8gEKFQwUCh0QAwoVOCgMEwoTOCkgBOEBCxM4HxQMFQXjAQsTAQoANgcLDxAGFDgqChQ4KwEKHQ8DCxQ4LAEF/QELDwEKHQ8DChU4LQwQCw4LEA8EFQ4KOBgGAAAAAAAAAAAhBIMCBYQCBTULHRADOCAEnAIKCQseDAcuCwc4NgEMHgoJCxw4LxEACgkKHgwILgsIODAMHAEOCjgYBgAAAAAAAAAAIQSmAgsAAQsJAQWnAgUcCwoLFwINAQAAV0gKAQoANwoUGQYAAAAAAAAAACEECQURCwABCwYBCwUBBwUnCwIEJwsACwEHGwsFET4LBDgRODcMCQwHDQMLBwoGOBk4OAsJCwY4GgwEBUULAQ4DODklBC0FNQsAAQsGAQsFAQcRJwsABxoLBRE+CwM4Dzg6DAgKBjgZDAMNBAsICwY4Gjg7CwMLBAIOAAAAWXUKBTgODA0KAwQeCgIKARE1DAsKADYBCwULCzg8CgA3CxQMCgoANwsUBgEAAAAAAAAAFgoANgsVCgA2CAwIBTIKADYACwUKAjg9CgA3DBQMCgoANwwUBgEAAAAAAAAAFgoANgwVCgA2AgwICgoKAQoCCgMKDQsEEgQMCQoICgEMBy4LBzgwDAwgBEsKCAoBCgEKBjg+EgU4PwwMCwgLDDgdDwMKCgsJOEAKADcGEVEUCgoLAwoNCwIKATkCOEEKADcHCg04QiAEagoANgcKDQsGOEM4RAVsCwYBCwA2BwsNOCoKCgsBOEULCgIPAQAAYPIBCgIGAAAAAAAAAAAkBAUFDwsAAQsIAQsGAQsHAQcFJwoBCgA3DRQZBgAAAAAAAAAAIQQYBSILAAELCAELBgELBwEHBCcKAgoANwoUGQYAAAAAAAAAACEEKwU1CwABCwgBCwYBCwcBBwUnCgQKBhE+JAQ7BUULAAELCAELBgELBwEHFCcKBzgODBMKAwRxCgA3AQoTOEYMEgoANgEKBwoSOEcMDgoACgIKAQsGET4LDjg3DBAMCg4KOBgMDAsSDhA4SBcMEQoANgAKEwsKOBAKADYBCxMLEDgSBZEBCgA2AAoHCgI4SQwJCgAKAQsGET4LCTg6DA8MCwoCDgs4GBcMDA4POEgMEQoANgAKEwsLOBAKADYBCxMLDzgSCgUHFyEEoAELAAELCAELBwELDAsRCQYAAAAAAAAAAAIKBQcYIQS2AQsAAQsIAQsHAQoMCwIhBK8BBbEBBwgnCwwLEQkGAAAAAAAAAAACCgUHGSEE1QEKDAYAAAAAAAAAACEEvwEFxwELAAELCAELBwEHCScLAAsBCwILAwsECwcLCDhKDA0LDAsRCAsNAgsFBxYhBNoBBeIBCwABCwgBCwcBBw0nCwALAQsCCgwXCwMLBAsHCwg4SgwNCwwLEQgLDQIQAAAAAQQLAAcbIwIRAAAAARMLAAoBEAwUCgEQFBQKARAGFAoBEAQUCwEQBxQ5AzhLAhIBAABjbgsCOA4MDAoANwcKDDhCBAkFDQsAAQcLJwoANgcKDDgqDA0KDQoBDAMuCwM4TAQaBSALDQELAAEHAicKDQoBDAQuCwQ4TRQMCwoBERAMCAoIBDEKADcIDAUFNAoANwIMBQsFCws4MAwKBDoFQAsNAQsAAQcCJwoIBEYKADYIDAYFSQoANgIMBgsGCw0LCgsBCgw4TgwJCwgEYA4JEAQUDgkQBxQRNQwHCgA2AQsMCwc4MwVnCgA2AAsMDgkQBBQ4IgsANwYRURQOCTgxAhMAAABkNgsBCgM4KwEKAAoCDAUuCwU4TxADCgM4UAQPBRMLAAEHAicKAAoCOB0MBgoGDwMLAzgsDAcOBxAGFAsEIQQjBSkLAAELBgEHAycLBhADOCAEMgsACwI4LxEABTQLAAELBwIUAQAAZWgKADcGEVEUDAsLATgODA0KADcHCg04QgQOBRILAAEGAAAAAAAAAAAnCgA2BwoNOCoMDgoOLjhRIARjBR0KDi44UjgfFAwJCg4KCQwCLgsCOE0UDAoKCREQDAYKBgQ0CgA2CAwDBTcKADYCDAMLAwwHCgcLCgwELgsEODAMDAELBwoOCwwLCQoNOE4MCAsGBFgOCBAEFA4IEAcUETUMBQoANgEKDQsFODMFXwoANgAKDQ4IEAQUOCIKCw4IODEFFwsOAQsAAQIVAQAAZqQBCgA3BhFRFAwQCwI4DgwTCgA3BwoTOEIEDgUSCwABBgAAAAAAAAAAJwYAAAAAAAAAAAwRCgA3CDgbIAQdCgA3CAwDBSAKADcCDAMLAwoROE8QFRQMEg4BQRQMCwYAAAAAAAAAAAwJCgA2BwoTOCoMFAoJCgsjBJ8BBTUOAQoJQhQUDA8KFAoPDAQuCwQ4TARCBUgLFAELAAEHAicKFAoPDAUuCwU4TRQMDQoPERAMCgoNChIiBHALDQwSCgoEXwoANwgMBgViCgA3AgwGCwYKEjgwDAwEaAVuCxQBCwABBwonCwwMEQoKBHYKADYIDAcFeQoANgIMBwsHChQKEQsPChM4TgwOCwoEkAEODhAEFA4OEAcUETUMCAoANgEKEwsIODMFlwEKADYAChMODhAEFDgiChAODjgxCwkGAQAAAAAAAAAWDAkFMAsUAQsAAQIWAQAAZ1QLATgODAcKADcHCwc4UwwIQBsAAAAAAAAAAAwDCgg4VAwFCgU4KSAETAUSCggKBTgfFDhNFAwGCgU4HxQREAQkCgA3CAsGOFUMAgUpCgA3AgsGOFUMAgsCEAMKBTgfFDghDAQNAwoEEAwUCgQQBxQKBBAEFAoEEBQUCgQQBhQLBBAFFBIERBsKCAsFOB8UOFYMBQUNCwgBCwABCwUBCwMCFwEAAGgUCwE4DgwGCgA3AAoGOFcMAwwCCwA3AQsGOFgMBQwECwILAwsECwUCGAEAAGlWCgA3CDgcAQwICgEKCCMECwsIDAEKADcIODIBDAcKAgoHJAQWCwcMAgoANwgLAThZDAEKADcICwI4WQwCQBQAAAAAAAAAAAwJQBQAAAAAAAAAAAwFCgEGAAAAAAAAAAAhBC8LAAELAwELCQsFAgoBCgIlBFMFNAoANwgKAQoDET44WgwEDQkKAUQUDQULBEQUCgA3CAsBOC4BDAYKBgYAAAAAAAAAACEEUAsAAQsDAQVTCwYMAQUvCwkLBQIZAQAAaVYKADcCOBwBDAgKAQoIIwQLCwgMAQoANwI4MgEMBwoCCgckBBYLBwwCCgA3AgsBOFkMAQoANwILAjhZDAJAFAAAAAAAAAAADAlAFAAAAAAAAAAADAUKAQYAAAAAAAAAACEELwsAAQsDAQsJCwUCCgEKAiUEUwU0CgA3AgoBCgMRPjhaDAQNCQoBRBQNBQsERBQKADcCCwE4LgEMBgoGBgAAAAAAAAAAIQRQCwABCwMBBVMLBgwBBS8LCQsFAhoAAABqMQsACwE4VRADDAYGAAAAAAAAAAAMAwoGOB4MBQoFOCkgBCsFDwoGCgU4HxQ4IQwECgQQBRQKAiQEIgsDCwQQBBQWDAMFJAsEAQoGCwU4HxQ4KAwFBQoLBgELBQELAwIbAQAAax0LAjgODAUKADcHCwU4UwoBOE0UDAQKAQcbIwQTCwA3CAwDBRYLADcCDAMLAwsEOFUQAwsBOCECBgoGCwYCBQEEAgQFBAQEAQYHBgYGDQYABAAGBQYBBg4GCQYDBgQGCAQDBQAANQE1AjUINQk1CjULNQ01DjUPNRA1ETUSNRM1AARtYXRosQKhHOsLBgAAAAcBAAIDAg8FEQ8HIB0IPSAGXRwMeZgBAAEAAgABAAADAAIAAAAAAgACAwMBAwIBAwIEBAMBBAQJZGl2X3JvdW5kBG1hdGgDbXVsCW11bF9yb3VuZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pAwgAypo7AAAAAAQQAMqaOwAAAAAAAAAAAAAAAAABAAADDQsANQwCCwE1DAMLAgsDGAcBGjQCAQEAAAQaCwA1DAMLATUMBAgMAgoDCgQYBwEZMgAAAAAAAAAAAAAAAAAAAAAhBBIJDAILAgsDCwQYBwEaNAICAQAABBwLADUMAwsBNQwECAwCCgMHADUYCgQZMgAAAAAAAAAAAAAAAAAAAAAhBBMJDAILAgsDBwA1GAsEGjQCAAdjcml0Yml02xyhHOsLBgAAAA4BAAYCBhwDIsIBBOQBNgWaAusBB4UEmQQInghABt4IeArWCTMLiQoEDI0K2REN5hscDoIcFA+WHAIADQErASwAAgYBAAAAAQYAAAAEAQQAAQMMAgcBBAECBAIAAB8AAQEEACoCAwEEABUCBAEEAB4CBQEEAB0CBQEEACQGBQEEACEGBQEEABoGAwEEACgGAwEEABMHAwEEABEGCAEEABAGAwEEACYJCgEEAAoJCwEEAAcGDAEEAAgGDAEEAA8BDQEGAA4BDQEEABIGAwEEAC0ODQEEABYPBAEEAAwQEQABBRoNAgcEAQYWFwIHBAEJHB4CBwQBDhMNAgcEAQ8TDQIHBgEVFQQCBwQBGxUDAgcEAR8AEwIHBAElHB0CBwQdEh0UHBQbFAIKFxQKChQKFxIICgcKFhQSChYSEwoGCgUKHhQBChgSGBQeEg4KGhIaFBkUGRIBBwgEAQsCAQkAAQYLAgEJAAEDAQECAwMCBgsCAQkAAwMHCwIBCQADCQACAQMCBwsCAQkAAwEJAAEHCQABBgkAAAQHCwIBCQADAwEDBgsCAQkAAwMBBAECAgMIAQELAwIJAAkBAgMLAAEJAAEGCwMCCQAJAQIGCwMCCQAJAQkAAQYJAQQBAwMDEAMDAwMDAgYIAQEBCAEDAwsAAQkAAwMDAwcLAwIJAAkBCQAJARADAwMDAwMDAwMBAwMGCAEDAwkAAgcLAwIJAAkBCQABCQEBBwkBAgsDAgMIAQsDAgMLAAEJAAIGCAEDAgICC0NyaXRiaXRUcmVlDEludGVybmFsTm9kZQRMZWFmBVRhYmxlCVR4Q29udGV4dANhZGQGYm9ycm93FGJvcnJvd19sZWFmX2J5X2luZGV4EmJvcnJvd19sZWFmX2J5X2tleQpib3Jyb3dfbXV0GGJvcnJvd19tdXRfbGVhZl9ieV9pbmRleARjbG9iE2NvdW50X2xlYWRpbmdfemVyb3MHY3JpdGJpdA1kZXN0cm95X2VtcHR5BGRyb3AQZmluZF9jbG9zZXN0X2tleQlmaW5kX2xlYWYdZ2V0X2Nsb3Nlc3RfbGVhZl9pbmRleF9ieV9rZXkLaW5zZXJ0X2xlYWYOaW50ZXJuYWxfbm9kZXMIaXNfZW1wdHkNaXNfbGVmdF9jaGlsZANrZXkGbGVhdmVzCmxlZnRfY2hpbGQObGVmdF9tb3N0X2xlYWYGbGVuZ3RoBG1hc2sIbWF4X2xlYWYIbWluX2xlYWYDbmV3GG5leHRfaW50ZXJuYWxfbm9kZV9pbmRleAluZXh0X2xlYWYPbmV4dF9sZWFmX2luZGV4BnBhcmVudA1wcmV2aW91c19sZWFmBnJlbW92ZRRyZW1vdmVfbGVhZl9ieV9pbmRleAtyaWdodF9jaGlsZA9yaWdodF9tb3N0X2xlYWYEcm9vdARzaXplBXRhYmxlCnR4X2NvbnRleHQMdXBkYXRlX2NoaWxkBXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMIAAAAAAAAAIADCP//////////Awj/////////fwACAxcDLgkAIwMBAgQcAxkDJwMjAwICBykDFAsDAgMIARgLAwIDCwABCQAeAx0DIAMiAwIKAAoAAwAADQsHCQoAOAALADgBBwkHCQYAAAAAAAAAAAYAAAAAAAAAADkAAgEDAAANBAsANwA4AgICAwAADQQLADcAOAMCAwMAAA0VCgA4BCAEBQUJCwABBwQnCgA3AAoANwEUOAU3AhQLADcBFAIEAwAADRUKADgEIAQFBQkLAAEHBCcKADcACgA3AxQ4BTcCFAsANwMUAgUBAAAYTgoACwE4BgwDAQoDBwkiBAoFDgsAAQcEJwcKCgMXDAUKADcACwM4BTcEFAwECgQHCSIEJAUeCgAKBAsFOAcMAgUmCQwCCwIEMgsEDAUKADcFCgU4CBAGFAwEBRkKBAcJIQQ7CwABBgAAAAAAAAAABwkCBwoKAAoANwULBDgIEAcUOAkXDAMLADcACgM4BTcCFAsDAgYDAAAYTwoACwE4BgwDAQoDBwkiBAoFDgsAAQcEJwcKCgMXDAUKADcACwM4BTcEFAwECgQHCSIEJQUeCgAKBAsFOAcgDAIFJwkMAgsCBDMLBAwFCgA3BQoFOAgQBhQMBAUZCgQHCSEEPAsAAQYAAAAAAAAAAAcJAgcKCgAKADcFCwQ4CBAIFDgKFwwDCwA3AAoDOAU3AhQLAwIHAAAAAxMLAQwCCgIHCSMEDwUHCgA3BQsCOAgQBxQMAgUCCwABCwICCAAAAAMTCwEMAgoCBwkjBA8FBwoANwULAjgIEAgUDAIFAgsAAQsCAgkDAAAZ9wEKAQsCBwk5AQwPCgA3BhQMEAoANwYUBgEAAAAAAAAAFgoANgYVChAHCwYBAAAAAAAAABcjBBgFHAsAAQcBJwoANgAKEAsPOAsKAAoBDAMuCwM4DAwHCgcHCSEERQoQBgAAAAAAAAAAIQQxBTULAAEHAicHCgoQFwoANgcVChAKADYBFQsQCwA2AxUGAAAAAAAAAAACCgA3AAsHOAU3AhQMBgoGCgEiBFEFVQsAAQcDJzFACwYKAR01ERUxQBcXDAgGAQAAAAAAAAALCDEBFy8MEQoRBwkHCQcJEgEMDAoANwgUDA0KADcIFAYBAAAAAAAAABYKADYIFQoANgUKDQsMOA0KADcHFAwSBwkMDgoSBwkjBKkBBYcBCgA3BQoSOAgMCQoRCgkQDBQkBJUBCwkBBakBCxIMDgoBCgkQDBQcBgAAAAAAAAAAIQSkAQsJEAcUDBIFqAELCRAIFAwSBYIBCg4HCSEEsgEKDQoANgcVBcEBCgAKDgoSDAUMBC4LBAsFOAcMCgoACw4KDQsKOA4LEQoBHAYAAAAAAAAAACEMCwoACg0HCgoQFwoLOA4KAAsNCxILCyA4DgoANwAKADcBFDgFNwIUCgEkBOMBChAKADYBFQoANwAKADcDFDgFNwIUCwEjBPMBChALADYDFQX1AQsAAQsQAgoDAAADGwoAOAQECAsAAQkHCQIKAAoBOAwMAgsANwAKAjgFNwIUCwEiBBgJBwkCCAsCAgsDAAADEgoAOAQEBwsAAQYAAAAAAAAAAAIKAAsBOAwMAgsANwALAjgFNwIUAgwDAAAbqwEKADcACgE4BTcCFAwMCgA3ARQKASEEGQoACgwMBC4LBDgPDAkBCwkKADYBFQoANwMUCgEhBCsKAAsMDAUuCwU4EAwKAQsKCgA2AxUKADYACgE4EToBDA8MEQEKAC44EgYAAAAAAAAAACEETgcJCgA2BxUHCQoANgEVBwkKADYDFQYAAAAAAAAAAAoANggVBgAAAAAAAAAACwA2BhUFqQEKDwcJIgRTBVcLAAEHBicKADcFCg84CAwOCg4QBhQMDQoACg8HCgsBFwwHDAYuCwYLBzgHBHELDhAIFAwIBXULDhAHFAwICwgMEAoNBwkhBJUBChAHCSMEhwEHCQoANgUKEDgTDwYVBZABBwkKADYABwoKEBc4FDYEFQsQCgA2BxUFpAEKAAoNCg8MAwwCLgsCCwM4BwwLCgALDQsQCws4DgsANgULDzgVAQsRAg0DAAANBgsANgALATgUNgkCDgMAAA0GCwA3AAsBOAU3CQIPAwAAAw4KAAsBOAYMAgQGBQoLAAEHBCcLAAsCOBYCEAMAAB8OCwA6AAEBAQEMAgwBAQsBOBcLAjgYAhEDAAAfFw4ANwA4AgYAAAAAAAAAACEEBwUJBgAAAAAAAAAAJwsAOgABAQEBDAIMAQELAjgZCwE4GgISAAAAIC4KADcHFAwDCgMHCSEEDAsAAQcJAgoDBwkjBCgFEQoANwULAzgIDAIKAQoCEAwUHAYAAAAAAAAAACEEIwsCEAcUDAMFJwsCEAgUDAMFDAsAAQcKCwMXAhMAAAANNwoBBwkiBAUFCQsAAQcHJwsDBBMKAgoANgUKATgTDwcVBRoKAgoANgUKATgTDwgVCgIHCSIENAoCBwkkBCwLAQsANgAHCgsCFzgUNgQVBTMLAQsANgULAjgTDwYVBTYLAAECFAAAAA0JCwA3BQsBOAgQBxQLAiECFQAAACFrCgAyAAAAAAAAAAAAAAAAAAAAACEEBzGADAEFaTEADAIKADIAAAAAAAAAAP//////////HDIAAAAAAAAAAAAAAAAAAAAAIQQXCwAxQC8MAAsCMUAWDAIKADIAAAAAAAAAAAAAAAD/////HDIAAAAAAAAAAAAAAAAAAAAAIQQlCwAxIC8MAAsCMSAWDAIKADIAAAAAAAAAAAAAAAAAAP//HDIAAAAAAAAAAAAAAAAAAAAAIQQzCwAxEC8MAAsCMRAWDAIKADIAAAAAAAAAAAAAAAAAAAD/HDIAAAAAAAAAAAAAAAAAAAAAIQRBCwAxCC8MAAsCMQgWDAIKADIAAAAAAAAAAAAAAAAAAADwHDIAAAAAAAAAAAAAAAAAAAAAIQRPCwAxBC8MAAsCMQQWDAIKADIAAAAAAAAAAAAAAAAAAADAHDIAAAAAAAAAAAAAAAAAAAAAIQRdCwAxAi8MAAsCMQIWDAILADIAAAAAAAAAAAAAAAAAAACAHDIAAAAAAAAAAAAAAAAAAAAAIQRnCwIxARYMAgsCDAELAQICAgIDAAACBAACAgEBAwEBAQICBgIAAgUBAAABAAoBCgIKAwoECgUKCQoKCgsKDQoACwAJY3VzdG9kaWFu2wyhHOsLBgAAAA4BAAwCDDADPKQBBOABHgX+AfYBB/QDwAQItAhABvQICgr+CCYLpAkEDKgJ4AINiAwIDpAMBg+WDAIAFwEPARUBIwElASYAAAQBAAEAAQwAAAQMAQABAQIEAQABAgMMAQABAwUHAAMIBAAEBgwCBwEEAQUHAgAAIQABAAAKAgMBAAAiAAQBAAAqBQYBAAArBQYBAAAcBwgBAAAYCQoBAAAdCwgBAAAZDAoBAAAfCQgBAAAoDAgBAAAJAg0BAAAMAg0BAAATDg8BAAARAhABAAEeGg0BAAEkHQoBAAEpFw0BAAEsCAoBAAIaGQYBAAMiABEAAycbHAAEDR8IAgcEBBAVFgIHBAQSICECBwQEFhUeAgcEBCIAGAIHBBcUERMaFAYTExMNEw8TEBMHEwgTBRMZFBITFhQYFAEHCAgBCAECBgsCAQkACAUCAwMBCwIBCQAEBwsCAQkAAwYIAQcICAELBAEJAAMHCwIBCQAIBQsDAQkAAAMHCwIBCQAGCAEDAQsDAQkAAwcLAgEJAAYIAQsDAQkAAwcLAgEJAAgFAwEDAgcLAgEJAAgFAQcLAAEJAAEGCwABCQABCAYDBgsAAQkAAwMBCQACCAULAAEJAAIGCwcCCQAJAQkAAQYJAQEGCwMBCQABCwcCCQAJAQILAwEJAAcICAIHCwMBCQALAwEJAAEGCAYBCAUCBwsDAQkAAwEBAwcLBwIJAAkBCQAJAQIHCwcCCQAJAQkAAQcJAQdBY2NvdW50CkFjY291bnRDYXAHQmFsYW5jZQRDb2luCUN1c3RvZGlhbgJJRAVUYWJsZQlUeENvbnRleHQDVUlEGWFjY291bnRfYXZhaWxhYmxlX2JhbGFuY2UPYWNjb3VudF9iYWxhbmNlEGFjY291bnRfYmFsYW5jZXMWYWNjb3VudF9sb2NrZWRfYmFsYW5jZQNhZGQRYXZhaWxhYmxlX2JhbGFuY2UHYmFsYW5jZQZib3Jyb3cWYm9ycm93X2FjY291bnRfYmFsYW5jZQpib3Jyb3dfbXV0GmJvcnJvd19tdXRfYWNjb3VudF9iYWxhbmNlBGNsb2IEY29pbghjb250YWlucwljdXN0b2RpYW4fZGVjcmVhc2VfdXNlcl9hdmFpbGFibGVfYmFsYW5jZRxkZWNyZWFzZV91c2VyX2xvY2tlZF9iYWxhbmNlDGZyb21fYmFsYW5jZQJpZB9pbmNyZWFzZV91c2VyX2F2YWlsYWJsZV9iYWxhbmNlHGluY3JlYXNlX3VzZXJfbG9ja2VkX2JhbGFuY2UEam9pbgxsb2NrX2JhbGFuY2UObG9ja2VkX2JhbGFuY2UQbWludF9hY2NvdW50X2NhcANuZXcGb2JqZWN0BXNwbGl0BXRhYmxlCnR4X2NvbnRleHQMdWlkX3RvX2lubmVyDnVubG9ja19iYWxhbmNlBXZhbHVlE3dpdGhkcmF3X2Jhc2VfYXNzZXQUd2l0aGRyYXdfcXVvdGVfYXNzZXQEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAEAAAAAAAAAAAICDgsDAQkAIAsDAQkAAQIBGwgGAgICGwgGCwsHAggFCwABCQACEwATAAEAAAgECwARFBIBAgEDAAASEAsANwALATgADAIKAjcBOAEMAwsCNwI4AQwECwMLBAICAwAACAYKABEUCwA4AjkAAgMDAAAIBwsACwILATgDCwM4BAIEAwAACAcLAAsCCwE4AwsDOAQCBQMAAAgICwALATgFNgELAjgGAQIGAwAACAkLAAsBEAMRFTgFNgELAjgHAgcDAAAICgsACwEQAxEVOAU2AgsCOAYBAggDAAAIBwsACwE4BTYCCwI4BwIJAwAACgoKAAoBCwI4AwwDCwALAQsDOAgCCgMAAAoKCgAKAQsCOAkMAwsACwELAzgKAgsDAAAIBwsANwALATgANwE4AQIMAwAACAcLADcACwE4ADcCOAECDQAAAAgSCgA3AAoBOAsgBA0KADYACgE4DDgMOQE4DQsANgALATgOAg4AAAAIDwoANwAKATgLBAYFCgsAAQcAJwsANwALATgAAgIBAAAAAQEAABMBEwITABQADQljdXN0b2RpYW4HQWNjb3VudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pCWN1c3RvZGlhbgpBY2NvdW50Q2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukJY3VzdG9kaWFuCUN1c3RvZGlhbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pB2NyaXRiaXQETGVhZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pB2NyaXRiaXQMSW50ZXJuYWxOb2RlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukHY3JpdGJpdAtDcml0Yml0VHJlZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pBGNsb2ILUG9vbENyZWF0ZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QRjbG9iC09yZGVyUGxhY2VkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukEY2xvYg1PcmRlckNhbmNlbGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukEY2xvYgtPcmRlckZpbGxlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pBGNsb2IFT3JkZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QRjbG9iCVRpY2tMZXZlbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pBGNsb2IEUG9vbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3JfY2FwH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAAAQAAAAAAAAAAQAB6m7J/DqSin0O78BL2X7p2wadLu9VHLQZenFeb3kNT7jVL4xqhzJpt7/k0yHfLDJvMAQYVZAeoSdHGasv23IwA7jVL4xqhzJpt7/k0yHfLDJvMAQYVZAeoSdHGasv23IwAAAEBAAAAAAAAAAAoBwnRr+4OFRx+9xpBP6AJklpKh6LPY0JTdxSt8dX+e9UAAENP15RqAAB7gyC3+hQw3PBZTqueIMXSiSbGrSFnT7J7B9e7Z4tH0QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wVUG9vbFRva2VuRXhjaGFuZ2VSYXRlAAAAAAAAAAAAADgJgyQCqIyQRy+mY2liaJT9XLzkvpaHnGw4Qij0ZLKSrwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQ9uAKu8Ui2h+FQIIoP7VHDM12ouG7gzh/2tXiexRDYAAAAQEAAAAAAAAAACgP1D99bZcbZxmGrfRoQc8o259Qr7C4O7rIT8oeB9qL/gAAQ0/XlGoAAEm6oy6kC0WlSQRKpDvVmSEvth0cl5DGNK9TnBwox9nbAAABAQAAAAAAAAAAKCEZKPioHQ6EK4IiUcJ2Izh65HrwDnMxA28tLtjn6Q3OAABDT9eUagAAe4Mgt/oUMNzwWU6rniDF0okmxq0hZ0+yewfXu2eLR9EAAAEBAAAAAAAAAAAoMEoY/4TSSDrtbdQFsnddu/i0vGYtST5T1Scm43rGdeIAAENP15RqAABJuqMupAtFpUkESqQ71ZkhL7YdHJeQxjSvU5wcKMfZ2wAAAQEAAAAAAAAAACg3wp7Ck8MlTWpxp7GXiccinMajVwLZRHXcIoS8UO5OewAAQ0/XlGoAAA0PBMs887515Y/9UZvSiCITFTbuMmwAfBPaR6cAnhQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX2NhcB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwAAEAAAAAAAAAAEBCsDx7L8K+gWjtx/EP+rtuYWR86pOMKzz58OWFnTKsJ2swbQww+L6NZtj1wibPCFcCRPBJ/Kd+mybJY5X5JRsSAGswbQww+L6NZtj1wibPCFcCRPBJ/Kd+mybJY5X5JRsSAAABAQAAAAAAAAAAKEo15hxpcX9gdgTVKPsZFcOwRXoHdvZsSS7BRpGG4NZ9AABDT9eUagAAtqGXTARPET/4NEhSJPrRIEHWQXOsaeobUpmOqmJRVi8AAAEBAAAAAAAAAAAoTOIyzQIJW6UJ1mmWUPER0Doz15id5dsSaCpvuigVK64AAENP15RqAABJuqMupAtFpUkESqQ71ZkhL7YdHJeQxjSvU5wcKMfZ2wAAAgAAAAAAAAAAAFBRKdl9Yt19UpGKCsmRSlDWhiQ3V8hUvA+NClz44p+gkeI0jXDjbx6aK976Je9kNGE85R4sU4I2M+QXJn6zBfXvAAAAAAAAAAAAAILf5A1HAABrMG0MMPi+jWbY9cImzwhXAkTwSfynfpsmyWOV+SUbEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdAJJRAAEAAAAAAAAAAAAYGB8ixQ1hNYIHBXqe9dADEimGtscnuYPPSoi7+HkkyUQtGV/WGQmZmM5afZqPb0zLkWfR3MjDRMsndwU8Si30PjuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjAEflfs97OKS9sv1olKzUyE89S6NfxKSRne06ngc38eeOgAAAQEAAAAAAAAAAChhtRNPzqDAFsnRbax9s8EBJ5UgmNN1OdDc4nwk0Q+4bwAAQ0/XlGoAALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAICBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXITU3VpU3lzdGVtU3RhdGVJbm5lcgAAAAAAAAAAAACfGmryorfKYL92F0rf0+nElX+Ok3dZYDGC+bRsf2xfGcbSAQAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAQAAAAAAAAAAAAh+kzccAQQdlqGWc4hYr9v2AUTi0cWqjRDVpFw3WhCtgvkiAFE0GmCNz/bRVQQKZW9IGbExEbUsV0aoa6cvOV+6/i7DhH0egUDmJKdR/fa18gULxyBc+dMABMkLDHQK/9Mmzmc8wrI6LSTVPir+sobfxmj9QGAInW0rF7eZ3Tb5DTMuVKejONQgXw9Cyz+yDdV3cDOIMglk+TUdmXMTwEoDIkcGDSFLLnEgNzcStuIbnPffsBHiunWHMc4LcUlzICVo1U95+8yxd0kwiyzWtDylvqPLC+t6rUZeJFE6XLu39wLim2VBbz6NAb3a9tiL09BgKVbugWjBAwqkC3ZhbGlkYXRvci0xAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zMzM1NS9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC80NjMzNRgvaXA0LzEyNy4wLjAuMS91ZHAvNDIwMzkYL2lwNC8xMjcuMC4wLjEvdWRwLzM5ODU5AAAAAAAAAAAHILRUHKflqCQ6XlUQIcvq3QMXSSZwaCnEEUgkkENUsQAAAAAAAAAAxAkAAAAAAACTUVVPz8b4Xk1FkdnT000IXQ4QZNveyI+mLkBEzvWKyugDAAAAAAAAKy99JiJBKTD5NRW3IWxgJIMbYO1PHb7BK6zx6IKb7MgBAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAk8OcOHHTZYqWVqUUx83pyU4uLCAM8PPRW5Mg+VhHpX4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyX/uAqGGEFaDV6mBiFQEslfqFrHjwiD4Ip+CIUUS9kAAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAAEcs98D4eYltE4bUFz9hTqzOoO+B21sTPFiPFEzAULNyAAAAAAAAAADuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjGCZ8l72H4AyuRRjZGCYLFzG8TTvHdrnZlfyy/7B6/yNCXN0CA32/PDcuLxLDY4K9dgOu/8rTFmfVPQtYxLfwxQnYHjBzDR+u77FGYviWFE/OGuTDQLCdJqAPiMwlV69GhAgzmDjB34Co2g0Nq9FDzpFEbTECxWJVmN8r5zPETkefhAgEWzsBHlYiAE3N5D0DGMCQVlkWIKcTt9IlzeiMQ0CFtwwi4uTNREZbHVnSkLgGmQBE40j2XtrTtF/mCMsCsMrnHONz/ga9tRpQKesAW2h857NC3ZhbGlkYXRvci0wAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zNjQ1OS9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC80NDA2MRgvaXA0LzEyNy4wLjAuMS91ZHAvMzY3NDUYL2lwNC8xMjcuMC4wLjEvdWRwLzM5NDEzAAAAAAAAAAAqj9QggOfSzl4V+GoGupp0zLLjFK7Ai/kU14Z0pcplwgAAAAAAAAAAxAkAAAAAAAAAepuyfw6kop9Du/AS9l+6dsGnS7vVRy0GXpxXm95DU+gDAAAAAAAAtGV/WGQmZmM5afZqPb0zLkWfR3MjDRMsndwU8Si30PgBAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAdk7bK8RROD8dpsPXdTNoXuGWH148/rlAHPlcYlgMuhsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOALCrjh1OlDO9wp3K37FsmQUyK0Z+1veXMy6WoD6PPpAAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAAMCoc8pdZWPKGUV6q+J5JXMc4SlHoBErQiqd4mV0fA7zAAAAAAAAAACRzKvCogqNa1yKYBCVcquLQ2r6tbMDzoDk8W3A3kTxCWCt3u+U2JjIjkDb3v+RxfEF+c8sdH+28rw37APWyR7bLhpXjPVEvosJMeJfJD1ZsMMNmKFs47odbPHX9QQmmS6wrbMTSwVb6BQNLbXyX7ANg/jkIivwH9ask6H/TXnaWPIgbZCVEwsVNsDJIY6p/rDzZoWm+gs7HmfSVsxPs0CkjWkg4aJsYZ6zZso+y9AJsSdyVwZpvS5xBIkFkHq/P1vVicAwg54KGo44DGyw4IzRjcWLzbg6Jk6yWiOvJMf7BMOaTNaad3ggvrve/e4nm6wmN8RBC3ZhbGlkYXRvci0yAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zNDYzMy9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC8zMjk2NRgvaXA0LzEyNy4wLjAuMS91ZHAvMzU0NTcYL2lwNC8xMjcuMC4wLjEvdWRwLzM4Nzc3AAAAAAAAAABTNhzYGW9m5KkSFn9ArSMiPdKVXpJY3m2tPt4e9IrJagAAAAAAAAAAxAkAAAAAAAB4lQ80jeOmoKV/UC9hBPicN/10aUq5MV0cEovDw1a5ZOgDAAAAAAAA6acBh9L1XSJ3yoBV6dqFMrxVeE0xtplrp4+c1CltCD4BAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAsKJKXbPSW1XP7jTBDgMK2GrtaGaWY4MGkj4hEakxfIQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGgWz9PGeUN9QEyThBHsL0qqjU3+ySOilTRettQOhqr+AAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAANQQ3CSl/J897uufZyU7yE/TheAJXn18ZUcAhNz0IoB9AAAAAAAAAABrMG0MMPi+jWbY9cImzwhXAkTwSfynfpsmyWOV+SUbEmCz/V77XIckA6StE/EZlRNgbSM1SoRSSa6hV1ZMI/88FcbJ5lK3LXQOjKy5PLzAaGsOwMwMHHYL+0K0NlGfxagFS3ZTOpep8jmH0JfvlrHyUmuyBz+hCncZlBdyNH7ydPQgspFb94eEWlXCThj9wWKldesC0juuP55WbXxR68/rSkIg8kw7zFaMQz00lCDtKETmq8+h3WPHxOET+m/+d8OLN5cwjH1jRasTAwXh522c5CGYCtEP3OL4+3AftEv/V5VTo84aM98Vcq7RvxQRQNNvdRjFC3ZhbGlkYXRvci0zAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zMzk1My9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC8zOTg4ORgvaXA0LzEyNy4wLjAuMS91ZHAvMzgxNzUYL2lwNC8xMjcuMC4wLjEvdWRwLzM0NjU1AAAAAAAAAAB5Bga3JMoC4IzRoFv5/VtYTjXap+MAb9AY/b0XUvqcEgAAAAAAAAAAxAkAAAAAAABCsDx7L8K+gWjtx/EP+rtuYWR86pOMKzz58OWFnTKsJ+gDAAAAAAAA4jSNcONvHpor3vol72Q0YTzlHixTgjYz5BcmfrMF9e8BAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAEPbgCrvFItofhUCCKD+1RwzNdqLhu4M4f9rV4nsUQ2ABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA960Qi0S0U6BDq5/IpdoN9qCAL0Mtadv9qsbqs0kX43AAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAALXy8lsznanogWAJQdi8BJRveAbXZAU0khL0/RuSvMUlAAAAAAAAAADyDLlENgEFhcdiENKB4e7ewpnQ11c5Rq+IXbCiPkqX5wAAAAAAAAAAAB+V+z3s4pL2y/WiUrNTITz1Lo1/EpJGd7TqeBzfx546BAAAAAAAAAD05hHSH05rAHQinJqI2qlgmwDYW0Ar1ZUlKvAb1YO3/AAAAAAAAAAAme3BiKhIlx5YejQ6LP0fUAchBVxU5UQnLbIE5YzOhjoAAAAAAAAAAAD8MKYtNUf67vuKdE6P5oQ1FIAoRKku2yiTHCg7VYAmMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcJgUAAAAAAAAAAAAAAACWAAAAAAAAAAAAQ0/XlGoAAACC3+QNRwAAgKGna0o1AAcAAAAAAAAAHYs50dCPQ6ybhPyI0uSJq3qb5mDjI+lgzdtX3nxAfZ4AAAAAAAAAAOgDAAAAAAAAAAAAVU5qYkJ/AAAAAAAAAAAAgMakfo0DAB4AAAAAAAAAECckK9UFd0RjYpGX8B3DEoyR+9yoxKKlGpdtNOBIobrHiQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyjYfxIcBAAAV2oCN7dMGWG9VQgN8pL4hchVVXQwtTLf/u3XRt82O5gAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGb2JqZWN0AklEAAQAAAAAAAAAAABgb0rk3QYBsEj0pF/BkzjEOSYlmBlF2nAEWrD4jmJlJ+TppwGH0vVdInfKgFXp2oUyvFV4TTG2mWunj5zUKW0IPpHMq8KiCo1rXIpgEJVyq4tDavq1swPOgOTxbcDeRPEJAR+V+z3s4pL2y/WiUrNTITz1Lo1/EpJGd7TqeBzfx546AAABAQAAAAAAAAAAKHKx8DBUNkciLx+XTdI3LScK3Siwiq8cMBOPiOeR0rh3AABDT9eUagAA7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3JfY2FwH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAAAQAAAAAAAAAAQHiVDzSN46agpX9QL2EE+Jw3/XRpSrkxXRwSi8PDVrlkkcyrwqIKjWtcimAQlXKri0Nq+rWzA86A5PFtwN5E8QkAkcyrwqIKjWtcimAQlXKri0Nq+rWzA86A5PFtwN5E8QkAAAEBAAAAAAAAAAAof9z54bG0U9spRw6CuIsOitWyfryr8yVXhnO0jjxEdTIAAENP15RqAAANDwTLPPO+deWP/VGb0ogiExU27jJsAHwT2kenAJ4UIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wVUG9vbFRva2VuRXhjaGFuZ2VSYXRlAAAAAAAAAAAAADiDz6sfwEs6e6UFCaJh56GmqbY2OlHw1RiI7jYOR4lecwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF2TtsrxFE4Px2mw9d1M2he4ZYfXjz+uUAc+VxiWAy6GwAAAgAAAAAAAAAAAFCD1k5PxPNdgUPU8A5P0F0T6TLQG53sFFWq/UuWbxuQA+mnAYfS9V0id8qAVenahTK8VXhNMbaZa6ePnNQpbQg+AAAAAAAAAAAAAILf5A1HAACRzKvCogqNa1yKYBCVcquLQ2r6tbMDzoDk8W3A3kTxCQAAAgAAAAAAAAAAAFCOslZQFQKLoOsYxUKJEEN4XruGB7gl4GZ2LPZxvoRX7LRlf1hkJmZjOWn2aj29My5Fn0dzIw0TLJ3cFPEot9D4AAAAAAAAAAAAAILf5A1HAADuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9jYXAfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAABAAAAAAAAAABAk1FVT8/G+F5NRZHZ09NNCF0OEGTb3siPpi5ARM71isodlqGWc4hYr9v2AUTi0cWqjRDVpFw3WhCtgvkiAFE0GgAdlqGWc4hYr9v2AUTi0cWqjRDVpFw3WhCtgvkiAFE0GgAAAQEAAAAAAAAAACiUHTR/XH5fbwyHvE1TeYoyKoXPuds/c+6AmN2EQAvwSQAAQ0/XlGoAALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYvAAABAQAAAAAAAAAAKJ/7yi7mbq/m1ZAvKcsKhNsxPcm1SkQYo2h7OSGm2bsCAABDT9eUagAADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCAAAAEBAAAAAAAAAAAoowF6v6fXTNgUKRMLWFp/vxhF6OFbgNXYnL5lqOhTv0UAAENP15RqAABJuqMupAtFpUkESqQ71ZkhL7YdHJeQxjSvU5wcKMfZ2wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBGNvaW4MQ29pbk1ldGFkYXRhAQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNzdWkDU1VJAAEAAAAAAAAAACulo9wBjqkC8AGuUEQlGdMOdmYxqXFPMJtJfaj6xSSanQkDU3VpA1NVSQAAAwAAAQEAAAAAAAAAACitUotCmNKFPIwUlrpLVnY1F86LElAt2Y+y4goD3IcMmwAAQ0/XlGoAAHuDILf6FDDc8FlOq54gxdKJJsatIWdPsnsH17tni0fRAAABAQAAAAAAAAAAKLQBvSjHw4eZ0wG+8gpJmO9MB+29FWXUh/+rE7+6hpRjAABDT9eUagAASbqjLqQLRaVJBEqkO9WZIS+2HRyXkMY0r1OcHCjH2dsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZvYmplY3QCSUQABAAAAAAAAAAAAGC1MJTIzFY4NvYcAOq40vVWuAJG9eQp/7hprGpOG1wz1+I0jXDjbx6aK976Je9kNGE85R4sU4I2M+QXJn6zBfXvazBtDDD4vo1m2PXCJs8IVwJE8En8p36bJsljlfklGxIBH5X7PezikvbL9aJSs1MhPPUujX8SkkZ3tOp4HN/HnjoAAAEBAAAAAAAAAAAowBx1aADkhKVJTlY2EpBTY9hsurCmQ8n29ubfYagI85IAAENP15RqAAANDwTLPPO+deWP/VGb0ogiExU27jJsAHwT2kenAJ4UIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdAJJRAAEAAAAAAAAAAAAYMf2wVcsuwFijHhbr+a98vGOgvplAtbqgTDzFUKsUF3tKy99JiJBKTD5NRW3IWxgJIMbYO1PHb7BK6zx6IKb7MgdlqGWc4hYr9v2AUTi0cWqjRDVpFw3WhCtgvkiAFE0GgEflfs97OKS9sv1olKzUyE89S6NfxKSRne06ngc38eeOgAAAQEAAAAAAAAAACjNTjbpEa5n6Z6lsDppQZByGyh6FJsoBAfGQESiqtLaugAAQ0/XlGoAAO2GcxXj98g66C5tWFi2psxXwpH9hPdQlkbryBYhac+WAAABAQAAAAAAAAAAKNKQI/yGML5+UrcwNODD/znzdiVrEcFIwPl1jImERDGLAABDT9eUagAA7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5YAAAEBAAAAAAAAAAAo1T22lKKDRmTdLP9D/wB6NDk4msdNiPXZdaEsMfwgyMkAAENP15RqAAC2oZdMBE8RP/g0SFIk+tEgQdZBc6xp6htSmY6qYlFWLwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wVUG9vbFRva2VuRXhjaGFuZ2VSYXRlAAAAAAAAAAAAADjWGyj7IpNTLEYSK13Xfkml+I1vcz5xoMsRrGb+jlm/8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGwokpds9JbVc/uNMEOAwrYau1oZpZjgwaSPiERqTF8hAAAAQEAAAAAAAAAACjbGg3kdS1Q/ZRxOkXtF5b6nZkMTlEctSFegndMluacrQAAQ0/XlGoAAA0PBMs887515Y/9UZvSiCITFTbuMmwAfBPaR6cAnhQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAICBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbBVQb29sVG9rZW5FeGNoYW5nZVJhdGUAAAAAAAAAAAAAONs2AkoAkytfpTPHVDBEzxI4VXQDI0RtOHAbYsKjKMN5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZPDnDhx02WKllalFMfN6clOLiwgDPDz0VuTIPlYR6V+AAABAQAAAAAAAAAAKN+Z5K7+QFhNp0EMDPe0fkc5ciqr9vp3MANEd6hvuWJuAABDT9eUagAAe4Mgt/oUMNzwWU6rniDF0okmxq0hZ0+yewfXu2eLR9EAAAEBAAAAAAAAAAAo4P3dPuRkdqB3a5GWQ1DY7gcnzUUTcE2dRnPz/E34UDwAAENP15RqAAC2oZdMBE8RP/g0SFIk+tEgQdZBc6xp6htSmY6qYlFWLwAAAQEAAAAAAAAAACjs7bZBm5EQ3apNFF9D04M2S9a1nowGcPhgUg0g6gaYLwAAQ0/XlGoAAO2GcxXj98g66C5tWFi2psxXwpH9hPdQlkbryBYhac+WAAABAQAAAAAAAAAAKO6xodBEIKA4CT/RgTexRuZLKamQ425++rBXsm6Bn8lSAABDT9eUagAA7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5YAAAIAAAAAAAAAAABQ92Ycv2dxXLpW8bw0qDukz8Ya/gPCpL+Oz6UpZdcLJRkrL30mIkEpMPk1FbchbGAkgxtg7U8dvsErrPHogpvsyAAAAAAAAAAAAACC3+QNRwAAHZahlnOIWK/b9gFE4tHFqo0Q1aRcN1oQrYL5IgBRNBoAAAEBAAAAAAAAAAAo+d1INR0JTR3V0tZZ6ugXDm72dmAfv2VMmStny60fHggAAENP15RqAAB7gyC3+hQw3PBZTqueIMXSiSbGrSFnT7J7B9e7Z4tH0QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAWEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAACDjcqtN5pwo5Nb1c6ks1QUqmoEZru8Ws5JPg1Hn3raaAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEAAAAAAAAAICel0DjkNZtMFRZv7rqp/JU41pYiJFBjPxSJJAxIw9caAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAQAAAAAAAAAgwjWmbRXIqdbkPWy7T8uSoKvnlNgzSuu8CQ3k2FYjr7MDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUBAAAAAAAAACCTJRzh97r6QVZnvkDY/YdPxyF7aSvKleIw1VbMhXKUvwIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAQAAAAAAAAAg8qT5uvuCJ4nIPk/mE/L0nhMNLUbjFROQ1ssPpJLhIkMCAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QEAAAAAAAAAIPWb9lpdCEgn3r0muvfRlIBZ+Zpzb0W7XluNNQ609wUlAwB6m7J/DqSin0O78BL2X7p2wadLu9VHLQZenFeb3kNTAQAAAAAAAAAg29Wei4gh/saFmNSdUhqf0F8Fym5uJATxRKdYKkSSOgoA7jVL4xqhzJpt7/k0yHfLDJvMAQYVZAeoSdHGasv23IwHCdGv7g4VHH73GkE/oAmSWkqHos9jQlN3FK3x1f571QEAAAAAAAAAINw6q+hLWxwiIuyLDVUHgyzA5c3brt8TPLl0oEWHCUu7AHuDILf6FDDc8FlOq54gxdKJJsatIWdPsnsH17tni0fRCYMkAqiMkEcvpmNpYmiU/Vy85L6Wh5xsOEIo9GSykq8BAAAAAAAAACA/WQ3kWsRwlLkNQCquk0NcDrdhGq6oDhpBfGjI1D3fpAEQ9uAKu8Ui2h+FQIIoP7VHDM12ouG7gzh/2tXiexRDYA/UP31tlxtnGYat9GhBzyjbn1CvsLg7ushPyh4H2ov+AQAAAAAAAAAgUXgGV6VFzZLBHHbgWbwgJ/rKzOkD4PEF4ihhBlBY8ekASbqjLqQLRaVJBEqkO9WZIS+2HRyXkMY0r1OcHCjH2dshGSj4qB0OhCuCIlHCdiM4euR68A5zMQNvLS7Y5+kNzgEAAAAAAAAAIPL0Qz+JlD5X1CYFeXIcVxmTkPwEx/FKBZlQTLUw0EyQAHuDILf6FDDc8FlOq54gxdKJJsatIWdPsnsH17tni0fRMEoY/4TSSDrtbdQFsnddu/i0vGYtST5T1Scm43rGdeIBAAAAAAAAACD2xePtIKth9kRN6aO++nJOrrqFJd4g/tEFjaa97Z0PxwBJuqMupAtFpUkESqQ71ZkhL7YdHJeQxjSvU5wcKMfZ2zfCnsKTwyVNanGnsZeJxyKcxqNXAtlEddwihLxQ7k57AQAAAAAAAAAgrnoS533yyZz/vHSupTrk2htWXPyzsl8iiDN6xk8PthUADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCBCsDx7L8K+gWjtx/EP+rtuYWR86pOMKzz58OWFnTKsJwEAAAAAAAAAIL2C6npy/nC2lumFdMhdab3/q93uhuVy87s4umFZ7+qvAGswbQww+L6NZtj1wibPCFcCRPBJ/Kd+mybJY5X5JRsSSjXmHGlxf2B2BNUo+xkVw7BFegd29mxJLsFGkYbg1n0BAAAAAAAAACDHAbW8ejeLdZ0Nmz+RINqZow/LOh38TFqsM9FR30zVfwC2oZdMBE8RP/g0SFIk+tEgQdZBc6xp6htSmY6qYlFWL0ziMs0CCVulCdZpllDxEdA6M9eYneXbEmgqb7ooFSuuAQAAAAAAAAAgTuvuKygRF1Xthw7uxjDqq6FNEveb7Fxf7IrwEIpbcgAASbqjLqQLRaVJBEqkO9WZIS+2HRyXkMY0r1OcHCjH2dtRKdl9Yt19UpGKCsmRSlDWhiQ3V8hUvA+NClz44p+gkQEAAAAAAAAAIPNPx311fuxSIfS1E0i0zBWtBwhRK5ZqqaK4e+5vF9iJAGswbQww+L6NZtj1wibPCFcCRPBJ/Kd+mybJY5X5JRsSYHyLFDWE1ggcFep710AMSKYa2xye5g89KiLv4eSTJRABAAAAAAAAACBDHG54hnZBfaPS1S16KcZ81WnsF/vLPqlxVAI2bsbVCgEflfs97OKS9sv1olKzUyE89S6NfxKSRne06ngc38eeOmG1E0/OoMAWydFtrH2zwQEnlSCY03U50NzifCTRD7hvAQAAAAAAAAAgGxqYt/IPremqIZbmslEBRZb6YTXXp9/5CoLbu2c2+cUAtqGXTARPET/4NEhSJPrRIEHWQXOsaeobUpmOqmJRVi9q8qK3ymC/dhdK39PpxJV/jpN3WWAxgvm0bH9sXxnG0gEAAAAAAAAAIHNF5f4hz8jlFU8iQ+W2B8pDL2r1R/gUjXyb6rVz5gIUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFb0rk3QYBsEj0pF/BkzjEOSYlmBlF2nAEWrD4jmJlJ+QBAAAAAAAAACA5oSmqaXyCr2QoE4+Jk2o/3A9eicMJPSxL5icSlWqUnwEflfs97OKS9sv1olKzUyE89S6NfxKSRne06ngc38eeOnKx8DBUNkciLx+XTdI3LScK3Siwiq8cMBOPiOeR0rh3AQAAAAAAAAAgZurQotONNbT7nHUBJH6KTnLEY97xsVvozr5HgXKVWzUA7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5Z4lQ80jeOmoKV/UC9hBPicN/10aUq5MV0cEovDw1a5ZAEAAAAAAAAAIP/cB/DPPVwioVsyxM5nxZ3uS2NoYm/NX+5uex9fINtuAJHMq8KiCo1rXIpgEJVyq4tDavq1swPOgOTxbcDeRPEJf9z54bG0U9spRw6CuIsOitWyfryr8yVXhnO0jjxEdTIBAAAAAAAAACA1a7ZCfI15YlTaMQO/daUlJNhuYNC4p7W9ou9AXAkk1QANDwTLPPO+deWP/VGb0ogiExU27jJsAHwT2kenAJ4UIIPPqx/ASzp7pQUJomHnoaaptjY6UfDVGIjuNg5HiV5zAQAAAAAAAAAgshSiHn8fu3XCVLVBhPpMTkp12/M0fS1Hd5GbmX/F7PQBdk7bK8RROD8dpsPXdTNoXuGWH148/rlAHPlcYlgMuhuD1k5PxPNdgUPU8A5P0F0T6TLQG53sFFWq/UuWbxuQAwEAAAAAAAAAIJ9v+RdIaU/4/aoNbdH8C4XCJN4C+7hkXYraZWU1BmkhAJHMq8KiCo1rXIpgEJVyq4tDavq1swPOgOTxbcDeRPEJjrJWUBUCi6DrGMVCiRBDeF67hge4JeBmdiz2cb6EV+wBAAAAAAAAACCuz244oX8bnTV7vpCBmXynRsSaK4ryAKRYlv9eOPl0CgDuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjJNRVU/PxvheTUWR2dPTTQhdDhBk297Ij6YuQETO9YrKAQAAAAAAAAAgtDd+w6MWTAW10L3q1RAPXWtAciKwLyTLF/Id5tvlaNoAHZahlnOIWK/b9gFE4tHFqo0Q1aRcN1oQrYL5IgBRNBqUHTR/XH5fbwyHvE1TeYoyKoXPuds/c+6AmN2EQAvwSQEAAAAAAAAAIGyvxtbb2r13ZpXrOIInpDV3NHhwnBEY/60ASFME/mOvALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYvn/vKLuZur+bVkC8pywqE2zE9ybVKRBijaHs5IabZuwIBAAAAAAAAACBQgwDjm3b61vAbTg9I2T0nQnCYlRkldbfE9FOEdBczEAANDwTLPPO+deWP/VGb0ogiExU27jJsAHwT2kenAJ4UIKMBer+n10zYFCkTC1haf78YRejhW4DV2Jy+ZajoU79FAQAAAAAAAAAg1iFCleW3z93Y7tAykNvkZl/BW0Ch3QFtXsydGmZUHlUASbqjLqQLRaVJBEqkO9WZIS+2HRyXkMY0r1OcHCjH2dulo9wBjqkC8AGuUEQlGdMOdmYxqXFPMJtJfaj6xSSanQEAAAAAAAAAIH8Zxjlh14TsKTeGDc0XVihHLinlgZWIWbCrUj4qJ2USA61Si0KY0oU8jBSWuktWdjUXzosSUC3Zj7LiCgPchwybAQAAAAAAAAAgwuzBOajNvIuvwI5pctW+HVeeWptHLPYjc4IjFM5zd38Ae4Mgt/oUMNzwWU6rniDF0okmxq0hZ0+yewfXu2eLR9G0Ab0ox8OHmdMBvvIKSZjvTAftvRVl1If/qxO/uoaUYwEAAAAAAAAAIO1otfFijkCfpJmkkaBxmWbF0DHlMtTCe7lnAnlp5bVaAEm6oy6kC0WlSQRKpDvVmSEvth0cl5DGNK9TnBwox9nbtTCUyMxWODb2HADquNL1VrgCRvXkKf+4aaxqThtcM9cBAAAAAAAAACDh5ltFTeTavE9iXt/+I71Ux0pFixIscS6+AYdmeh2zHwEflfs97OKS9sv1olKzUyE89S6NfxKSRne06ngc38eeOsAcdWgA5ISlSU5WNhKQU2PYbLqwpkPJ9vbm32GoCPOSAQAAAAAAAAAgObkup1OXZfFWCcTu0wTyHZUbxE7fQvHsBgiWlYv3QiAADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCDH9sFXLLsBYox4W6/mvfLxjoL6ZQLW6oEw8xVCrFBd7QEAAAAAAAAAIKoh0kQ0OGN7nF3KabRcouUqwISyh+dFfk8VWxBcYlVuAR+V+z3s4pL2y/WiUrNTITz1Lo1/EpJGd7TqeBzfx546zU426RGuZ+mepbA6aUGQchsoehSbKAQHxkBEoqrS2roBAAAAAAAAACCdrC+SASWACln2ZWCH89A+fercvwokJm9sM7MCsLqvGADthnMV4/fIOugubVhYtqbMV8KR/YT3UJZG68gWIWnPltKQI/yGML5+UrcwNODD/znzdiVrEcFIwPl1jImERDGLAQAAAAAAAAAgjeVPXClBdV7jadH4zZ0yscEKJxzCLSsS8FO7jSPPnw0A7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5bVPbaUooNGZN0s/0P/AHo0OTiax02I9dl1oSwx/CDIyQEAAAAAAAAAILSoSOvSAdEgY4nH5zJ0FW4vOXrmlxq5UsdQID0ezse5ALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYv1hso+yKTUyxGEitd135JpfiNb3M+caDLEaxm/o5Zv/EBAAAAAAAAACDh1Scv5MF+zS+Kp1swwXN3TluiE/6zlrLg6QcpiuRkWQGwokpds9JbVc/uNMEOAwrYau1oZpZjgwaSPiERqTF8hNsaDeR1LVD9lHE6Re0XlvqdmQxOURy1IV6Cd0yW5pytAQAAAAAAAAAgZ4tBj7oADXapSWZzh8xPJaRD602p/X7REJKUcwmYYIMADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCDbNgJKAJMrX6Uzx1QwRM8SOFV0AyNEbThwG2LCoyjDeQEAAAAAAAAAIA4hvOtvNvLuGmKAYpTNBF4c3h6EWGMC9YhcgYzARI/sAZPDnDhx02WKllalFMfN6clOLiwgDPDz0VuTIPlYR6V+35nkrv5AWE2nQQwM97R+RzlyKqv2+ncwA0R3qG+5Ym4BAAAAAAAAACA71ZURncD/L8tqSHrlcUeig0kfuFQeOFxTeI+fkpXCLAB7gyC3+hQw3PBZTqueIMXSiSbGrSFnT7J7B9e7Z4tH0eD93T7kZHagd2uRlkNQ2O4HJ81FE3BNnUZz8/xN+FA8AQAAAAAAAAAgFtaEibIOehaz8j3S+Pj1TS/6wouMp3adnAh5TFib+KoAtqGXTARPET/4NEhSJPrRIEHWQXOsaeobUpmOqmJRVi/s7bZBm5EQ3apNFF9D04M2S9a1nowGcPhgUg0g6gaYLwEAAAAAAAAAIHkQyGA3pPFPi8r1degkioJSfriLIQR8FrqMat2FonurAO2GcxXj98g66C5tWFi2psxXwpH9hPdQlkbryBYhac+W7rGh0EQgoDgJP9GBN7FG5kspqZDjbn76sFeyboGfyVIBAAAAAAAAACBehUyclb13bZ/hDXvPcTzaP7FfsvjyqhR9Ha/QJHzPhQDthnMV4/fIOugubVhYtqbMV8KR/YT3UJZG68gWIWnPlvdmHL9ncVy6VvG8NKg7pM/GGv4DwqS/js+lKWXXCyUZAQAAAAAAAAAgVRyYKBL2Gw8IaMwkVMUcXUJBdBTFhN8dm6ODKi9ENd0AHZahlnOIWK/b9gFE4tHFqo0Q1aRcN1oQrYL5IgBRNBr53Ug1HQlNHdXS1lnq6BcObvZ2YB+/ZUyZK2fLrR8eCAEAAAAAAAAAINC7DyYr5O+gLOJ1KwB+qwyC+JGqEl0dO6m/kUEc0UpBAHuDILf6FDDc8FlOq54gxdKJJsatIWdPsnsH17tni0fRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAAAAAAAACwNiY3NcoRzrCwYAAAAGAQACAwIGBQgHBw8NCBwgDDwEAAAAAQABAQABBgkAAQoCA2Jjcwh0b19ieXRlcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAECAAAEaGFzaGqhHOsLBgAAAAYBAAIDAgoFDAMHDxcIJiAMRggAAAABAAAAAAIAAAABCgIEaGFzaAhzaGEyXzI1NghzaGEzXzI1NgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAECAAEBAgAABWFzY2lplwahHOsLBgAAAAsBAAQCBA4DElQEZggFbjsHqQHIAQjxAiAGkQMKCpsDCwymA7oCDeAFBAAFABAAAgcAAAAHAAEBBwEAAAAIAAEAABQCAwAAFQIEAAADBQYAABIHCAAAEQkBAAAOBQoAAAQFCwAACgMCAAAGAQAAAA0ABgAACwAGAAEJDQ4BAAEMDAYBAAEPCA0BAAETDg0BAA0DDAMOAw8DAQIBCAEBCgIBCAABCwIBCAABBggAAQECBwgACAEAAQcIAAEDAQYKAgEGCwIBCQABCwIBCQABCQACAwMEQ2hhcgZPcHRpb24GU3RyaW5nGGFsbF9jaGFyYWN0ZXJzX3ByaW50YWJsZQhhc19ieXRlcwVhc2NpaQRieXRlBWJ5dGVzBGNoYXIMZGVzdHJveV9zb21lCmludG9fYnl0ZXMRaXNfcHJpbnRhYmxlX2NoYXIHaXNfc29tZQ1pc192YWxpZF9jaGFyBmxlbmd0aARub25lBm9wdGlvbghwb3BfY2hhcglwdXNoX2NoYXIEc29tZQZzdHJpbmcKdHJ5X3N0cmluZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAEAAAAAAAACAQcKAgECAQYCAAEAAAgJCgARCgQEBQYHACcLABIBAgEBAAAEDAsAEQIMAQ4BOAAEBwUJBwAnCwE4AQICAQAADx4OAEEADAIGAAAAAAAAAAAMASgKAQoCIwQZBQsOAAoBQgAUEQogBBQ4AgILAQYBAAAAAAAAABYMAQUFKAsAEgA4AwIDAQAADyAKABAAQQAMAgYAAAAAAAAAAAwBKAoBCgIjBB0FDAoAEAAKAUIAFBELIAQYCwABCQILAQYBAAAAAAAAABYMAQUGKAgCBAEAAAgHCwAPAA4BEAEURAACBQEAAAgFCwAPAEUAEgECBgEAAAgECwARB0EAAgcBAAAIAwsAEAACCAEAAAgDCwATAAIJAQAACAMLABMBAgoBAAAIBAsAMX8lAgsBAAAGDQoAMSAmBAkLADF+JQwBBQsJDAELAQIAAAEAAAVkZWJ1Z3ShHOsLBgAAAAYBAAIDAgsFDQUHEh4IMCAMUAgAAAABAAEBAAACAQEAAQYJAAAFZGVidWcFcHJpbnQRcHJpbnRfc3RhY2tfdHJhY2UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQABAgABAQIAAAZvcHRpb27xCKEc6wsGAAAADQEABAIEBgMKeASCAQ4FkAGHAQeXAtsBCPIDIAaSBBQKpgQHC60EAgyvBIAEDa8IAg6xCAIADwAWAAAHAQAAAA4AAQEAABECAQEAAAwDBAEAAA0DBAEAAAQFBAEAAAEDBgEAAAMFBgEAAAoHAgEDAAkIAAEAAAgJAgEAAAIJCgEAABIIAgEAABMIAQEAAAcLAgECAAYBAgEAAAUBAAEAABQBDAEAAQQOBAEAAQsNBAEAARACDAEAEwISAhECAwIAAgECAgIAAQsAAQkAAQkAAQYLAAEJAAEBAgYLAAEJAAYJAAEGCQACBgsAAQkACQACBwsAAQkACQABBwsAAQkAAQcJAAILAAEJAAkAAQoJAAEGCgkAAgYKCQAGCQACBgkABgoJAAIJAAYKCQABBwoJAAIJAAcKCQADCwABCQALAAEJAAcKCQACCQAKCQAGT3B0aW9uBmJvcnJvdwpib3Jyb3dfbXV0E2JvcnJvd193aXRoX2RlZmF1bHQIY29udGFpbnMMZGVzdHJveV9ub25lDGRlc3Ryb3lfc29tZRRkZXN0cm95X3dpdGhfZGVmYXVsdAdleHRyYWN0BGZpbGwQZ2V0X3dpdGhfZGVmYXVsdAhpc19lbXB0eQdpc19ub25lB2lzX3NvbWUEbm9uZQZvcHRpb24Jc2luZ2xldG9uBHNvbWUEc3dhcAxzd2FwX29yX2ZpbGwGdG9fdmVjA3ZlYwZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAEAAAAAAADCAEABAAAAAAAAAIBFQoJAAACAAEAAAADQAIAAAAAAAAAADkAAgEBAAAABAsAOAA5AAICAQAAAAQLADcAOAECAwEAAAAFCwA3ADgBIAIEAQAAAAULADcACwE4AgIFAQAAAA0KADgDBAQFCAsAAQcBJwsANwAGAAAAAAAAAABCAgIGAQAADxMLADcADAMKAzgBBAsLAwELAQwCBRELAQELAwYAAAAAAAAAAEICDAILAgIHAQAAEBILADcADAMKAzgBBAsLAwELAQwCBRALAwYAAAAAAAAAAEICFAwCCwICCAEAABEQCwA2AAwCCgIuOAEECAUMCwIBBwAnCwILAUQCAgkBAAAADQoALjgDBAUFCQsAAQcBJwsANgBFAgIKAQAAAA4KAC44AwQFBQkLAAEHAScLADYABgAAAAAAAAAAQwICCwEAABIUCgAuOAMEBQUJCwABBwEnCwA2AAwDCgNFAgwCCwMLAUQCCwICDAEAABMVCwA2AAwECgQuOAEECjgEDAIFDgoERQI4BQwCCwIMAwsECwFEAgsDAg0BAAAUDwsAOgAMAw0DLjgBBAoLAQwCBQ0NA0UCDAILAgIOAQAAFBAOADgDBAQFBgcBJwsAOgAMAg0CRQIMAQsCRgIAAAAAAAAAAAsBAg8BAAAACg4AOAYEBAUGBwAnCwA6AEYCAAAAAAAAAAACEAEAAAADCwA6AAIAAAACAAZzdHJpbmf5B6Ec6wsGAAAACwEACAIIDgMWcgSIAQgFkAF7B4sC+AEIgwQgBqMEFAq3BAYMvQSFAw3CBwIAEwAEABEAGAABBwABAQcAAgAHAQAAABcAAQAABgIBAAAVAQIAABYAAwAABQQFAAAOBAYAAA8EBwAAAggJAAADCgkAAAgLCQAAFAwBAAAHDQcAAAkFBgAACw4GAAAMDwAAAAoQBwABDQIAAAETAAIAAhAJEgEAAhIREgEAAwIVCQEAAw4UBgEAEwESARUTFBMBCgIBCAABCAEBCwIBCAABBggAAQYKAgEBAQMCBwgACAAAAgcIAAoCAwcIAAMIAAMGCAADAwIGCAAGCAACBgoCAwMGCgIDAwIGCgIGCgIBCQABCwIBCQABAgEGCgkAAgcKCQAKCQAIAQMDAwYKAggACAADBQEBAQYKAgMGT3B0aW9uBlN0cmluZwZhcHBlbmQLYXBwZW5kX3V0ZjgFYXNjaWkFYnl0ZXMKZnJvbV9hc2NpaQhpbmRleF9vZgZpbnNlcnQTaW50ZXJuYWxfY2hlY2tfdXRmOBFpbnRlcm5hbF9pbmRleF9vZhlpbnRlcm5hbF9pc19jaGFyX2JvdW5kYXJ5E2ludGVybmFsX3N1Yl9zdHJpbmcKaW50b19ieXRlcwhpc19lbXB0eQZsZW5ndGgEbm9uZQZvcHRpb24Ec29tZQZzdHJpbmcKc3ViX3N0cmluZwh0b19hc2NpaQh0cnlfdXRmOAR1dGY4BnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgBAAAAAAAAAAMIAgAAAAAAAAAAAgEFCgIAAQAACQkOABEMBAQFBgcAJwsAEgACAQEAAAkECwAREBIAAgIBAAAJBAsAEwAREQIDAQAAAwwOABEMBAgLABIAOAAMAQUKOAEMAQsBAgQBAAAJAwsAEAACBQEAAAkECwAQADgCAgYBAAAJBAsAEABBEwIHAQAACQcLAA8ADgEQABQ4AwIIAQAACQULAAsBEQARBwIJAQAAFjgKABAADAcKAQoHQRMlBA0LBwoBEQ0MAwURCwcBCQwDCwMEFAUYCwABBwEnCgAuEQYMCgoACgEMBC4GAAAAAAAAAAALBBEKDAkKAAsBCwoMBgwFLgsFCwYRCgwIDQkLAhEHDQkLCBEHCwkLABUCCgEAABcwCwAQAAwGCgZBEwwHCgILByUEDwoBCgIlDAMFEQkMAwsDBBgKBgoBEQ0MBAUaCQwECwQEIQoGCgIRDQwFBSMJDAULBQQmBSoLBgEHAScLBgsBCwIRDhIAAgsBAAAJBgsAEAALARAAEQ8CDAACAA0AAgAOAAIADwACAAAAAAZ2ZWN0b3KRCKEc6wsGAAAACAEAAgMCZgRoBAVsYQfNAZoBCOcCIAaHAwoMkQPYBAARAAUAAQEAAAkCAwEAAAEEBQEAAAsGAAEAAAIHCAEAAAoJCgEAAAQBAAEAAA8LAAEAAA4KAQEAAA0JAAEAAAAMAAEAAAgCDQEAAAMODQEAAAYODwEAAAwHCgEAAAcQAAEAABAHCgEACQoLCgABCgkAAQYKCQABAwIGCgkAAwEGCQACBwoJAAkAAgcKCQADAQcJAAEHCgkAAQkAAwcKCQADAwIHCgkACgkAAQECBgoJAAYJAAIBAwMHCgkACQADAwMDAwIDAwMDBwoJAAMGYXBwZW5kBmJvcnJvdwpib3Jyb3dfbXV0CGNvbnRhaW5zDWRlc3Ryb3lfZW1wdHkFZW1wdHkIaW5kZXhfb2YGaW5zZXJ0CGlzX2VtcHR5Bmxlbmd0aAhwb3BfYmFjawlwdXNoX2JhY2sGcmVtb3ZlB3JldmVyc2UJc2luZ2xldG9uBHN3YXALc3dhcF9yZW1vdmUGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAgAAAAAAAAECAAEBAgACAQIAAwECAAQBAgAFAQIABgECAAcBAgAIAQAAAQdACgAAAAAAAAAADAENAQsARAoLAQIJAQAAESYKAC5BCgwDCgMGAAAAAAAAAAAhBAsLAAECBgAAAAAAAAAADAILAwYBAAAAAAAAABcMAQoCCgEjBCMFFgoACgIKAUcKCwIGAQAAAAAAAAAWDAILAQYBAAAAAAAAABcMAQURCwABAgoBAAAAEQ0BOAAOATgBIAQMBQcKAA0BRQpECgUCCwABCwFGCgAAAAAAAAAAAgsBAAAABQsAQQoGAAAAAAAAAAAhAgwBAAASIQYAAAAAAAAAAAwCCgBBCgwDCgIKAyMEGwUKCgAKAkIKCgEhBBYLAAELAQEIAgsCBgEAAAAAAAAAFgwCBQULAAELAQEJAg0BAAASIwYAAAAAAAAAAAwCCgBBCgwDCgIKAyMEHAUKCgAKAkIKCgEhBBcLAAELAQEICwICCwIGAQAAAAAAAAAWDAIFBQsAAQsBAQkGAAAAAAAAAAACDgEAABMlCgAuQQoMBAoBCgQmBAwLAAEHACcLBAYBAAAAAAAAABcMBAoBCgQjBCIFFQoADAMKAQwCCwEGAQAAAAAAAAAWDAELAwsCCgFHCgUQCwBFCgIPAQAAAyAKAC5BCgwDCgIKAyQEDAsAAQcAJwoACwFECgoCCgMjBB0FFAoACgIKA0cKCwIGAQAAAAAAAAAWDAIFDwsAAQIQAQAAAxcKAC44ASAEBgUKCwABBwAnCgAuQQoGAQAAAAAAAAAXDAIKAAsBCwJHCgsARQoCAAdhZGRyZXNzZaEc6wsGAAAABgEAAgMCBQUHAwcKDwgZIAw5EAAAAAEAAQAAAQMHYWRkcmVzcwZsZW5ndGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQABAAAAAgYgAAAAAAAAAAIACXR5cGVfbmFtZYwEoRzrCwYAAAAKAQAGAgYIAw4pBTcsB2N5CNwBIAb8AQcKgwIGDIkC0wEN3AMCAA0AAgAEAAEHAAIABwAABgABAQAABQIDAAAHAgQAAAgCBAAACQEEAAEKAAYAAgMDBwACDAkEAAABCAABBggAAQYIAQEIAQQKAgMDBgoCAQMBBgoCAQIBCgIFAgYCAwoCBgoCBlN0cmluZwhUeXBlTmFtZQdhZGRyZXNzCGFzX2J5dGVzBWFzY2lpDWJvcnJvd19zdHJpbmcDZ2V0C2dldF9hZGRyZXNzCmdldF9tb2R1bGULaW50b19zdHJpbmcGbGVuZ3RoBG5hbWUGc3RyaW5nCXR5cGVfbmFtZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgE6CgIBAAACAQsIAQABAgABAQAAAAMLABAAAgIBAAAFIREFBgIAAAAAAAAAGAwDCwAQABEGDAQHAQwBBgAAAAAAAAAADAIKAgoDIwQcBRENAQoECgJCCBRECAsCBgEAAAAAAAAAFgwCBQwLBAELAREHAgMBAAAKJxEFBgIAAAAAAAAAGAYCAAAAAAAAABYMAwsAEAARBgwFBwEMBAoFCgNCCAwCBwAMAQoCDgEiBCAFFw0ECwIURAgLAwYBAAAAAAAAABYMAwUMCwUBCwIBCwQRBwIEAQAAAAQOABAAFAIAAAAKYml0X3ZlY3RvcqsGoRzrCwYAAAAKAQACAgIEAwYjBSkkB01tCLoBIAbaASgKggIIDIoC7wMN+QUEAAIAAAcAAAYAAQAABwIDAAAJAgMAAAgCAwAAAwQFAAAEBgAAAAUEAAABAwEIAAIHCAADAAIGCAADAQEBBggAAgoBAwEHAQUDBwEDAwMJQml0VmVjdG9yCWJpdF9maWVsZApiaXRfdmVjdG9yDGlzX2luZGV4X3NldAZsZW5ndGggbG9uZ2VzdF9zZXRfc2VxdWVuY2Vfc3RhcnRpbmdfYXQDbmV3A3NldApzaGlmdF9sZWZ0BXVuc2V0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAgAAAAAAAwgBAAIAAAAAAAMIAQAAAAAAAAADCAAEAAAAAAAAAAICBAMBCgEAAQAAByUKAAYAAAAAAAAAACQEBQUHBwEnCgAHAyMEDAUOBwEnBgAAAAAAAAAADAJABQAAAAAAAAAADAEoCgIKACMEIAUYDQEJRAULAgYBAAAAAAAAABYMAgUSKAsACwESAAIBAQAACBQKAQoAEABBBSMEBwULCwABBwAnCwAPAAsBQwUMAggLAhUCAgEAAAgUCgEKABAAQQUjBAcFCwsAAQcAJwsADwALAUMFDAIJCwIVAgMBAAAJWQoBCgAQARQmBCEKABAAQQUMBgYAAAAAAAAAAAwECgQKBiMEHgURCgAPAAoEQwUMAwkLAxULBAYBAAAAAAAAABYMBAUMCwABBVgKAQwFCgUKABABFCMEQQUqCgAKBQwCLgsCEQQENwoACgUKARcRAQU8CgAKBQoBFxECCwUGAQAAAAAAAAAWDAUFIwoAEAEUCwEXDAUKBQoAEAEUIwRWBU4KAAoFEQILBQYBAAAAAAAAABYMBQVHCwABAgQBAAADEQoBCgAQAEEFIwQHBQsLAAEHACcLABAACwFCBRQCBQEAAAMECwAQAEEFAgYBAAAAJQoBCgAQARQjBAcFCwsAAQcAJwoBDAIKAgoAEAEUIwQhBRQKAAoCEQQgBBwLAAEFIQsCBgEAAAAAAAAAFgwCBQ0LAgsBFwIAAQAAAA1maXhlZF9wb2ludDMy1gShHOsLBgAAAAoBAAICAgQDBh4FJBYHOnoItAEgBtQBRAqYAgUMnQKJAg2mBAIABAAABwAABwABAAADAAEAAAECAwAAAgEDAAAFAwEAAAYDBAACAwgAAQMCAwMBCAABAQEEBAEEBAQADEZpeGVkUG9pbnQzMhRjcmVhdGVfZnJvbV9yYXRpb25hbBVjcmVhdGVfZnJvbV9yYXdfdmFsdWUKZGl2aWRlX3U2NA1maXhlZF9wb2ludDMyDWdldF9yYXdfdmFsdWUHaXNfemVybwxtdWx0aXBseV91NjQFdmFsdWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQQ//////////8AAAAAAAAAAAMIAQABAAAAAAADCAIAAgAAAAAAAwgDAAIAAAAAAAMIBAABAAAAAAADCAUAAgAAAAAAAAIBCAMAAQAABRQLADUOARAAFDUYMSAwDAIKAgcAJQQPBREHAycLAjQCAQEAAAUdDgEQABQGAAAAAAAAAAAiBAcFCQcEJwsANTEgLw4BEAAUNRoMAgoCBwAlBBgFGgcCJwsCNAICAQAABjAKADUxQC8MBQsBNTEgLwwECgQyAAAAAAAAAAAAAAAAAAAAACIEDwURBwEnCwULBBoMAwoDMgAAAAAAAAAAAAAAAAAAAAAiBBwIDAIFIAsABgAAAAAAAAAAIQwCCwIEIwUlBwUnCgMHACUEKgUsBwUnCwM0EgACAwEAAAcDCwASAAIEAQAABwQOABAAFAIFAQAABwYOABAAFAYAAAAAAAAAACECAAAABw1maXhlZF9wb2ludDMyDEZpeGVkUG9pbnQzMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBm9wdGlvbgZPcHRpb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQVhc2NpaQZTdHJpbmcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQVhc2NpaQRDaGFyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEKYml0X3ZlY3RvcglCaXRWZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQZzdHJpbmcGU3RyaW5nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEJdHlwZV9uYW1lCFR5cGVOYW1lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAyA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQAAAAAAAAApA2JhZ+wFoRzrCwYAAAALAQAIAggMAxRwBIQBDAWQAVIH4gG5AQibAyAGuwMKCsUDCAzNA+YBDbMFBAAEAAsAEgAVAAAMAAICBAADAQIAABEAAQAAAwIDAgcEAAUEBQIHBAAGBgcCBwQAEwYIAgcEAAcECQEHAAgECQIHBAAQCgsAAA8KCQAACgEDAAEDDgMCBwQBBQ8FAgcEAQYQBwIHBAEMDwkBBwENDwkCBwQBExAIAgcEAgkMAwACEQAMAAoNCw0MDQ8NDREODQEHCAIBCAADBwgACQAJAQACBggACQABBgkBAgcIAAkAAQcJAQEJAQEBAQYIAAEDAQgBAgkACQEDBwgBCQAJAQIGCAEJAAIHCAEJAAEJAAIIAQMDQmFnCVR4Q29udGV4dANVSUQDYWRkA2JhZwZib3Jyb3cKYm9ycm93X211dAhjb250YWlucxJjb250YWluc193aXRoX3R5cGUGZGVsZXRlDWRlc3Ryb3lfZW1wdHkNZHluYW1pY19maWVsZAdleGlzdHNfEGV4aXN0c193aXRoX3R5cGUCaWQIaXNfZW1wdHkGbGVuZ3RoA25ldwZvYmplY3QGcmVtb3ZlBHNpemUKdHhfY29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAACAg4IARQDAAEAAAMFCwAREQYAAAAAAAAAABIAAgEBAAADDgoADwALAQsCOAAKABABFAYBAAAAAAAAABYLAA8BFQICAQAAAwULABAACwE4AQIDAQAAAwULAA8ACwE4AgIEAQAACA8KAA8ACwE4AwwCCgAQARQGAQAAAAAAAAAXCwAPARULAgIFAQAAAwULABAACwE4BAIGAQAAAwULABAACwE4BQIHAQAAAwQLABABFAIIAQAAAwYLABABFAYAAAAAAAAAACECCQEAABIOCwATAAwCDAELAgYAAAAAAAAAACEECQULBwAnCwEREAIAAAABAANiY3OVD6Ec6wsGAAAACwEACgIKCgMUhwEEmwEYBbMBgwEHtgLeAgiUBUAG1AU3CosGBgyRBssIDdwOAgADAQMBCgEfAAIAAAcAAgEHAQAAAB4AAQEAAAgBAgAABgIBAAALAwQAAAwDBQAAFAMGAAATAwcAABIDCAAAFwMHAAAVAwkAABYDCgAAGgMBAAAbAwsAABkDDAAAGAMNAAANAw4AAA4DDwAAEQMQAAAQAxEAAA8DEgABHgABAQACCRMhAQACHRQhAQADHBUTAQAEBQEEAAQHEwcAFBQXBhYEFQQWBRUFFgYVBhYHFQcWCBUIAQYJAAEKAgEIAAEHCAABBQEBAQIBAwEEAQoFAQoBAQoKAgEKAwEKBAELAQEFAQsBAQEBCwEBAgELAQEDAQsBAQQAAQkAAQcKCQACCgIDAgECAwMCAwMEAgQEAwMCAwMDAwoFAwMDCgEDAwMKAgMDAwoKAgMDAwoDAwMDCgQBCwEBCQADQkNTBk9wdGlvbgdhZGRyZXNzA2JjcwVieXRlcwpmcm9tX2J5dGVzFGludG9fcmVtYWluZGVyX2J5dGVzBmxlbmd0aANuZXcEbm9uZQZvcHRpb24McGVlbF9hZGRyZXNzCXBlZWxfYm9vbBNwZWVsX29wdGlvbl9hZGRyZXNzEHBlZWxfb3B0aW9uX2Jvb2wQcGVlbF9vcHRpb25fdTEyOA9wZWVsX29wdGlvbl91NjQOcGVlbF9vcHRpb25fdTgJcGVlbF91MTI4CHBlZWxfdTY0B3BlZWxfdTgQcGVlbF92ZWNfYWRkcmVzcw1wZWVsX3ZlY19ib29sD3BlZWxfdmVjX2xlbmd0aA1wZWVsX3ZlY191MTI4DHBlZWxfdmVjX3U2NAtwZWVsX3ZlY191OA9wZWVsX3ZlY192ZWNfdTgHcmV2ZXJzZQRzb21lCHRvX2J5dGVzBnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAAKBQEACgEBAAoCAQAKCgIBAAoDAQAKBAEAAAIBBAoCAAEAABMDCwA4AAIBAQAAEwUNADgBCwASAAICAQAAAQcLABMADAENATgBCwECAwEAABYjCgAQAEEGERkmBAcFCwsAAQcAJ0AGAAAAAAAAAAAGAAAAAAAAAAAMAgwBCgIRGSMEHgUUDQEKAA8ARQZEBgsCBgEAAAAAAAAAFgwCBQ8LAAELAREYAgQBAAAXFQsAEQUMAgoCMQAhBAoJDAEFEwsCMQEhBA8FEQcBJwgMAQsBAgUBAAATDwoAEABBBgYBAAAAAAAAACYEBwULCwABBwAnCwAPAEUGAgYBAAAYKAoAEABBBgYIAAAAAAAAACYEBwULCwABBwAnBgAAAAAAAAAAMQAMAgwDCgIxQCMEJAUUCgAPAEUGNAwBCwMLAQoCLxYMAwsCMQgWDAIFDwsAAQsDAgcBAAAZKAoAEABBBgYQAAAAAAAAACYEBwULCwABBwAnMgAAAAAAAAAAAAAAAAAAAAAxAAwCDAMKAjGAIwQkBRQKAA8ARQY1DAELAwsBCgIvFgwDCwIxCBYMAgUPCwABCwMCCAEAABowBgAAAAAAAAAAMQAGAAAAAAAAAAAMAgwDDAQKAgYEAAAAAAAAACUECwUPCwABBwInCgAPAEUGNAwBCwIGAQAAAAAAAAAWDAILBAoBBn8AAAAAAAAAHAoDLxsMBAsBBoAAAAAAAAAAHAYAAAAAAAAAACEEJwUsCwMxBxYMAwUGCwABCwQCCQEAABsZCgARCAYAAAAAAAAAAAcDDAMMAQwCCgEKAiMEFQUMDQMKABEDRAQLAQYBAAAAAAAAABYMAQUHCwABCwMCCgEAABwZCgARCAYAAAAAAAAAAAcEDAMMAQwCCgEKAiMEFQUMDQMKABEERAULAQYBAAAAAAAAABYMAQUHCwABCwMCCwEAAB0ZCgARCAYAAAAAAAAAAAcFDAMMAQwCCgEKAiMEFQUMDQMKABEFRAYLAQYBAAAAAAAAABYMAQUHCwABCwMCDAEAAB4ZCgARCAYAAAAAAAAAAAcGDAMMAQwCCgEKAiMEFQUMDQMKABELRAELAQYBAAAAAAAAABYMAQUHCwABCwMCDQEAAB8ZCgARCAYAAAAAAAAAAAcHDAMMAQwCCgEKAiMEFQUMDQMKABEGRAcLAQYBAAAAAAAAABYMAQUHCwABCwMCDgEAACAZCgARCAYAAAAAAAAAAAcIDAMMAQwCCgEKAiMEFQUMDQMKABEHRAgLAQYBAAAAAAAAABYMAQUHCwABCwMCDwEAAA4OCgARBAQICwARAzgCDAEFDAsAATgDDAELAQIQAQAADw4KABEEBAgLABEEOAQMAQUMCwABOAUMAQsBAhEBAAAQDgoAEQQECAsAEQU4BgwBBQwLAAE4BwwBCwECEgEAABEOCgARBAQICwARBjgIDAEFDAsAATgJDAELAQITAQAAEg4KABEEBAgLABEHOAoMAQUMCwABOAsMAQsBAgAAAANoZXizCqEc6wsGAAAACAEABAMEFQQZAgUbJQdALAhsQAasAZ8GDMsHwgIABAEFAAMAAAAAAQAAAAACAQEAAQADBAEAAwEBCgIBAgUKCgIHCgIDAwoCAgcKCQAKCQAABAIDAwoCBQEBAQICBmFwcGVuZAZkZWNvZGULZGVjb2RlX2J5dGUGZW5jb2RlA2hleAZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAAKCgKCBoACAjAwAjAxAjAyAjAzAjA0AjA1AjA2AjA3AjA4AjA5AjBhAjBiAjBjAjBkAjBlAjBmAjEwAjExAjEyAjEzAjE0AjE1AjE2AjE3AjE4AjE5AjFhAjFiAjFjAjFkAjFlAjFmAjIwAjIxAjIyAjIzAjI0AjI1AjI2AjI3AjI4AjI5AjJhAjJiAjJjAjJkAjJlAjJmAjMwAjMxAjMyAjMzAjM0AjM1AjM2AjM3AjM4AjM5AjNhAjNiAjNjAjNkAjNlAjNmAjQwAjQxAjQyAjQzAjQ0AjQ1AjQ2AjQ3AjQ4AjQ5AjRhAjRiAjRjAjRkAjRlAjRmAjUwAjUxAjUyAjUzAjU0AjU1AjU2AjU3AjU4AjU5AjVhAjViAjVjAjVkAjVlAjVmAjYwAjYxAjYyAjYzAjY0AjY1AjY2AjY3AjY4AjY5AjZhAjZiAjZjAjZkAjZlAjZmAjcwAjcxAjcyAjczAjc0Ajc1Ajc2Ajc3Ajc4Ajc5AjdhAjdiAjdjAjdkAjdlAjdmAjgwAjgxAjgyAjgzAjg0Ajg1Ajg2Ajg3Ajg4Ajg5AjhhAjhiAjhjAjhkAjhlAjhmAjkwAjkxAjkyAjkzAjk0Ajk1Ajk2Ajk3Ajk4Ajk5AjlhAjliAjljAjlkAjllAjlmAmEwAmExAmEyAmEzAmE0AmE1AmE2AmE3AmE4AmE5AmFhAmFiAmFjAmFkAmFlAmFmAmIwAmIxAmIyAmIzAmI0AmI1AmI2AmI3AmI4AmI5AmJhAmJiAmJjAmJkAmJlAmJmAmMwAmMxAmMyAmMzAmM0AmM1AmM2AmM3AmM4AmM5AmNhAmNiAmNjAmNkAmNlAmNmAmQwAmQxAmQyAmQzAmQ0AmQ1AmQ2AmQ3AmQ4AmQ5AmRhAmRiAmRjAmRkAmRlAmRmAmUwAmUxAmUyAmUzAmU0AmU1AmU2AmU3AmU4AmU5AmVhAmViAmVjAmVkAmVlAmVmAmYwAmYxAmYyAmYzAmY0AmY1AmY2AmY3AmY4AmY5AmZhAmZiAmZjAmZkAmZlAmZmCgIBAAABAAACIQYAAAAAAAAAAAcDDgBBAQwEDAUMAwoDCgQjBB8FDA0FDAIHAgwBCwIOAQ4ACgNCARQ0QgAUOAALAwYBAAAAAAAAABYMAwUHCwUCAQEAAAUvBgAAAAAAAAAABwMOAEEBDAMMBAwCCgMGAgAAAAAAAAAZBgAAAAAAAAAAIQQOBRAHACcKAgoDIwQtBRUOAAoCQgEUEQIxEBgOAAoCBgEAAAAAAAAAFkIBFBECFgwBDQQLAUQBCwIGAgAAAAAAAAAWDAIFEAsEAgIAAAAGQDEwCgAlBAkKADE6IwwBBQsJDAELAQQSCwAxMBcMBQU+MUEKACUEGwoAMUcjDAIFHQkMAgsCBCYxCgsAFjFBFwwEBTwxYQoAJQQvCgAxZyMMAwUxCQwDCwMENAU2BwEnMQoLABYxYRcMBAsEDAULBQIAA3BhecMGoRzrCwYAAAAJAQAIAggKAxJNBF8OBW1+B+sBrQEImAMgBrgDCgzCA9YCAAkAAgAPABABAAwBAAEDAQIAAAgAAQEAAAwCAQEAAA4DAQEAAA0EAQEAAAMCAQEAAAUFAQEAAAYGAQEAAAcHAQEAAQQCEAEAAQUFAQEAAQwCCgEAAgoLAQEMAwsICQALCgoMAAwBDAgMCQwGDAILAAEJAAYIAQADBwsAAQkAAwcIAQMHCwABCQAKAwcIAQQHCwABCQADBQcIAQIHCwABCQALAAEJAAIHCwABCQAKCwABCQACCgsAAQkABQEGCAEBBQELAAEJAAIJAAUBCQACAwMBAwMDAwoLAAEJAAEKCwABCQADCwABCQADAwRDb2luCVR4Q29udGV4dARjb2luD2RpdmlkZV9hbmRfa2VlcA1kaXZpZGVfaW50b19uBGpvaW4Iam9pbl92ZWMVam9pbl92ZWNfYW5kX3RyYW5zZmVyBGtlZXADcGF5D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIFc3BsaXQSc3BsaXRfYW5kX3RyYW5zZmVyCXNwbGl0X3ZlYwh0cmFuc2Zlcgp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAAEAAAEFCwALAREMOAACAQEEAAEICwALAQoCOAELAi44AgICAQQADRsGAAAAAAAAAAAOAUEODAQMAwoDCgQjBBYFCgoADgEKA0IOFAoCOAMLAwYBAAAAAAAAABYMAwUFCwABCwIBAgMBBAABBwsACwELAzgBCwI4AAIEAQQADx8LAAsBCgI4BAwFBgAAAAAAAAAADgVBCgwEDAMKAwoEIwQaBQ8NBUUKCgIuEQw4AAsDBgEAAAAAAAAAFgwDBQoLAgELBUYKAAAAAAAAAAACBQEEAAEECwALATgFAgYBBAARGgYAAAAAAAAAAA4BQQoMBAwDCgMKBCMEFQUKDQFFCgwCCgALAjgFCwMGAQAAAAAAAAAWDAMFBQsAAQsBRgoAAAAAAAAAAAIHAQQAChIOAEEKBgAAAAAAAAAAJAQGBQgHACcNAEUKDAINAgsAOAYLAgsBOAACAANzdWnYBqEc6wsGAAAACgEADgIOMAM+PgR8DgWKAYUBB48CgQIIkARABtAEZgq2BQUMuwVtABYBEgAJAAoAFwAZABoABAIAAQMHAQAAAgAEAQABAgUEAQABAwEMAQABAwIMAQABAwYMAQABBQcCAAYIBwAAEAABAAAXAgMAAREDCQEAAgwQBwEAAg8REgEAAwsLDAECAxgPEAEABBMOAwEMBBQUAwEMBQ4FBwAFFQUGAAIIBQoHDQYKBAoDCggTAQcIBwELAgEIAAILBAEIAAUABAsFAQgACwMBCAALAgEIAAsGAQgAAQYIBwEFAQMBCAgBCwEBCQABCAAHCQACCgIKAgoCCwEBCAgHCAcCCwYBCQALBQEJAAELBQEIAAEJAAELBgEJAAELAwEJAAIHCwMBCQADAQsCAQkAAQsEAQgAAgkABQdCYWxhbmNlBENvaW4MQ29pbk1ldGFkYXRhBk9wdGlvbgNTVUkGU3VwcGx5C1RyZWFzdXJ5Q2FwCVR4Q29udGV4dANVcmwHYmFsYW5jZQRjb2luD2NyZWF0ZV9jdXJyZW5jeQ5kZXN0cm95X3N1cHBseQtkdW1teV9maWVsZAVlcG9jaA9pbmNyZWFzZV9zdXBwbHkDbmV3BG5vbmUGb3B0aW9uFHB1YmxpY19mcmVlemVfb2JqZWN0D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIDc3VpCHRyYW5zZmVyFHRyZWFzdXJ5X2ludG9fc3VwcGx5CnR4X2NvbnRleHQDdXJsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgAypo7AAAAAAMIAOQLVAIAAAADCAAA6IkEI8eKBSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCBANTVUkKAgQDU3VpCgIBAAACAQ0BAAAAAAQvCgAuEQoHBSEEBwULCwABBwEnCgAuEQkGAAAAAAAAAAAhBBIFFgsAAQcAJwkSADEJBwYHBwcIOAALADgBDAEMBAsBOAILBDgDDAINAgcEOAQMAwsCOAUBCwMCAQEEAAMECwALATgGAgADdXJsqgKhHOsLBgAAAAkBAAQCBAgDDBkFJRQHOU4IhwFACscBBgzNATIN/wECAAgBAgABBwABAAcAAAQAAQAABQIBAAADAwAAAAcEBQABBgIAAAEIAQEIAAEKAgEGCAACBwgACAEABlN0cmluZwNVcmwFYXNjaWkJaW5uZXJfdXJsCm5ld191bnNhZmUVbmV3X3Vuc2FmZV9mcm9tX2J5dGVzBnN0cmluZwZ1cGRhdGUDdXJsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQACAQgIAQABAAAFAwsAEgACAQEAAAUECwARBBIAAgIBAAAFBAsAEAAUAgMBAAAFBQsBCwAPABUCAAAABGNvaW6BEqEc6wsGAAAADQEAFgIWPgNUmwIE7wIkBZMD4wIH9gWiBQiYC0AG2AseCvYLNAuqDAgMsgz0BA2mEQ4OtBEOAA8BCwEtATIADAAZACwAOQA7ADwAQQABDAEAAQACDAEAAQAHDAEAAQADAwEAAQEFBwACBAcBAAADBQcABAAEAQABBAYEAQABBgkEAAgIAgAKCgcAADgAAQEAADoCAwEAADMEBQEAADQEBgEAAEMHAQEAAAwHCAEAAA0JCgEAABoLDAEAACMMDQEAADcODAEAAC8PEAEAACUREAEAADESDAEAABcSEwEAAEQUDAEAABYMEAEAABAVFgECACYXDAEAACgYDQEAAA4ZAQEAACcaEAEAAD8bEAEAAEAcEAEAAD0bEAEAAD4cEAEAABsdHgEAAB4dHwEAAB8dIAEAABwdHwEAAB0dIQEAATIqIAACMCIvAQADQiofAAQRIgMBAgQTLAEBAAQWDRABAAQiKw0BAAQlJQEBAAQxJA0BAAQ1BQEBAARDCAEBAAREEA0BAAUYIhABAwYUIxAABioUIwAHLi0QAQwJJCcoAQIKKyAuACciKCImIggiJSIJIgQiDCIpIiMiLiIqKSEiJCIiIhEiLQwfLgEGCwIBCQABAwELAgEJAAELCAEJAAEHCwIBCQABBgsIAQkAAQcLCAEJAAEGCwABCQABBgsHAQkAAQcLAAEJAAEHCwcBCQACCwcBCQAHCAoBCwABCQABCwcBCQADBwsHAQkAAwcICgIHCwcBCQALAAEJAAACBwsAAQkACwABCQADBwsAAQkAAwcICgEKCwABCQABBwgKBwkAAgoCCgIKAgsFAQgLBwgKAgsCAQkACwEBCQADBwsCAQkAAwcICgIHCwIBCQADAgcLAgEJAAsAAQkABAcLAgEJAAMFBwgKAwYLAgEJAAcLAQEJAAgGAwYLAgEJAAcLAQEJAAgEAQYLAQEJAAECAQgGAQgEAQsFAQgLAQkAAQgJAgcLBwEJAAMCBwsHAQkACwcBCQADAwMKCwABCQABBgkAAQEBCwMBCQABCgICBwsIAQkAAwIHCwgBCQALBwEJAAIJAAUBCAsBCwUBCQAHQmFsYW5jZQRDb2luDENvaW5NZXRhZGF0YQ9DdXJyZW5jeUNyZWF0ZWQGT3B0aW9uBlN0cmluZwZTdXBwbHkLVHJlYXN1cnlDYXAJVHhDb250ZXh0A1VJRANVcmwFYXNjaWkHYmFsYW5jZQtiYWxhbmNlX211dARidXJuBGNvaW4PY3JlYXRlX2N1cnJlbmN5DWNyZWF0ZV9zdXBwbHkIZGVjaW1hbHMPZGVjcmVhc2Vfc3VwcGx5BmRlbGV0ZQtkZXNjcmlwdGlvbgxkZXN0cm95X3plcm8NZGl2aWRlX2ludG9fbgRlbWl0BWV2ZW50DGZyb21fYmFsYW5jZQxnZXRfZGVjaW1hbHMPZ2V0X2Rlc2NyaXB0aW9uDGdldF9pY29uX3VybAhnZXRfbmFtZQpnZXRfc3ltYm9sCGljb25fdXJsAmlkD2luY3JlYXNlX3N1cHBseQxpbnRvX2JhbGFuY2UTaXNfb25lX3RpbWVfd2l0bmVzcwRqb2luBG1pbnQRbWludF9hbmRfdHJhbnNmZXIMbWludF9iYWxhbmNlBG5hbWUDbmV3Cm5ld191bnNhZmUGb2JqZWN0Bm9wdGlvbg9wdWJsaWNfdHJhbnNmZXIDcHV0BHNvbWUFc3BsaXQGc3RyaW5nBnN1cHBseQpzdXBwbHlfbXV0DHN1cHBseV92YWx1ZQZzeW1ib2wEdGFrZQx0b3RhbF9zdXBwbHkIdHJhbnNmZXIUdHJlYXN1cnlfaW50b19zdXBwbHkKdHhfY29udGV4dAV0eXBlcxJ1cGRhdGVfZGVzY3JpcHRpb24PdXBkYXRlX2ljb25fdXJsC3VwZGF0ZV9uYW1lDXVwZGF0ZV9zeW1ib2wDdXJsBHV0ZjgFdmFsdWUEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAAAAgIhCAkMCwcBCQABAgYhCAkSAikIBjYIBBUIBiALBQEICwICAiEICTgLCAEJAAMCARICAiIAIgMiASIAAQAAEAQLADcAOAACAQEAAAMGCwA6AAwBESsLAQICAQAAEAMLADcAAgMBAAAQAwsANgACBAEAABAECwA3ATgBAgUBAAAQAwsANwECBgEAABADCwA2AQIHAQAAEAULAREsCwA5AQIIAQAADQYLADoBDAERKwsBAgkBAAAQBwsCESwLAAsBOAI5AQIKAQAAEAYLAAsBOAM4BAECCwEEAA0KCwE6AQwCESsLADYBCwI4BAECDAEAABAGCwA2AQsBCwI4BQINAQAAJjsKAQYAAAAAAAAAACQEBQULCwABCwIBBwEnCgEKAC44BiUEEgUYCwABCwIBBwInQAwAAAAAAAAAAAwFBgAAAAAAAAAADAMKAC44BgoBGgwEKAoDCgEGAQAAAAAAAAAXIwQ1BSoNBQoACgQKAjgHRAwLAwYBAAAAAAAAABYMAwUiCwABCwIBCwUCDgEAABAFCwARLDgIOQECDwEAAA0HCwA6AQwBESsLATgJAhABAAAQHA4AOAoEBAUICwYBBwAnCgE5AjgLCgYRLAsAOAw5AAsGESwLAQsDESALAhEeCwQRIAsFOQMCEQEAABAICwIRLAsANgALATgNOQECEgEAABAFCwA2AAsBOA0CEwEEAA0JCwE6AQwCESsLADYACwI4DgIUAQQAEAcLAAsBCwM4DwsCOBACFQEEABAFCwILATYCFQIWAQQAEAULAgsBNgMVAhcBBAAQBQsCCwE2BBUCGAEEABAHCwIRLzgRCwE2BRUCGQEAABAECwA3BhQCGgEAABAECwA3AhQCGwEAABAECwA3AxQCHAEAABAECwA3BBQCHQEAABAECwA3BRQCAgEAAQECAQMBBAEFAQEAIgEiAiIDIgQiBSIGIgAEaGFzaHGhHOsLBgAAAAYBAAIDAgoFDAcHExoILSAMTQgAAQAAAAEAAAIAAQABBgoCAQoCCmJsYWtlMmIyNTYEaGFzaAlrZWNjYWsyNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgABAgABAQIAAARobWFjZKEc6wsGAAAABgEAAgMCBQUHCgcREwgkIAxEBAAAAAEAAQACBgoCBgoCAQoCBGhtYWMNaG1hY19zaGEzXzI1NgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAAEbWF0aKcFoRzrCwYAAAAGAQACAwIjBSUSBzc5CHAgDJAB+QMAAgADAAEAAAQAAQAAAAABAAAFAgEAAAYBAQAABwMDAAABAAEAAgMDAQMCAwIBBAMEBAQDDw8PBGRpZmYTZGl2aWRlX2FuZF9yb3VuZF91cARtYXRoA21heANtaW4DcG93BHNxcnQJc3FydF91MTI4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQAAAQsKAAoBJAQHCwAMAgUJCwEMAgsCAgEBAAABCwoACgEjBAcLAAwCBQkLAQwCCwICAgEAAAEPCgAKASQECQsACwEXDAIFDQsBCwAXDAILAgIDAQAAASEGAQAAAAAAAAAMAgoBMQEmBB8FBwoBMQIZMQAhBBYKAAsAGAwACwExAhoMAQUeCwIKABgMAgsBMQEXDAEFAgsCAgQBAAAEKzIAAAAAAAAAAAEAAAAAAAAADAEyAAAAAAAAAAAAAAAAAAAAAAwCCwA1DAMKATIAAAAAAAAAAAAAAAAAAAAAIgQoBQwKAwoCCgEWJgQfCwMKAgoBFhcMAwsCMQEwCgEWDAIFIwsCMQEwDAILATECMAwBBQcLAjQCBQEAAAUrSgAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAADAFKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAgsATQwDCgFKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiBCgFDAoDCgIKARYmBB8LAwoCCgEWFwwDCwIxATAKARYMAgUjCwIxATAMAgsBMQIwDAEFBwsCNQIGAQAAARMKAAoBGQYAAAAAAAAAACEECwsACwEaDAIFEQsACwEaBgEAAAAAAAAAFgwCCwICAAVjbG9ja6IDoRzrCwYAAAALAQAIAggMAxQfBDMCBTUeB1N6CM0BIAbtASwKmQIIDKECTw3wAgIAAwAHAAsADAAACAABAgQAAwECAAAKAAEAAAUCAwAABAQDAAEDAwYAAgkIAwEIAwgCBQAEBwEGCAABAwEGCAIAAwcIAAMGCAIBBQEIAQEIAAEJAAVDbG9jawlUeENvbnRleHQDVUlEBWNsb2NrGWNvbnNlbnN1c19jb21taXRfcHJvbG9ndWUGY3JlYXRlAmlkBm9iamVjdAZzZW5kZXIMc2hhcmVfb2JqZWN0DHRpbWVzdGFtcF9tcwh0cmFuc2Zlcgp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgYIAQoDAAEAAAMECwAQABQCAQAAAAMNCwARBQcBIQQGBQgHACcRAwYAAAAAAAAAABIAOAACAgAAAAMPCwIRBQcBIQQGBQoLAAEHACcLAQsADwAVAgABAAVlY3ZyZooBoRzrCwYAAAAHAQACAwIFBQcPBxYTCCkgBkkeDGcEAAAAAQABAAQGCgIGCgIGCgIGCgIBAQVlY3ZyZgxlY3ZyZl92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAABAgAABWV2ZW50V6Ec6wsGAAAABgEAAgMCBgUIBAcMCwgXIAw3BAABAAAAAQEDAQkAAARlbWl0BWV2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQIAAAVraW9za8odoRzrCwYAAAANAQAWAhZSA2jOAgS2AzgF7gPsAwfaB/MGCM0OQAaND3gKhRBRC9YQBAzaEJkMDfMcEg6FHQYALgE3ABMAGAAbABwAHgA2AEwATgBPAAYMAAAHDAAACwwBDAEAAQAAAAQHAAAIBwAACQcAAAUDAQwBAQoHAQAAAgAEAQABAwIMAQABBwMHAAcQBAAIDAIACQ0MAQABCQ4AAQABCg8CAAA0AAEAABcCAwAASgQFAABLBgUAADkHBQEMADIIBQEMAE0JCgEMADALBQEMADoMBQEMAD8NDgEMADEPEAEMAEMRDgEMAEYSBQEMAFQTAwAAIxQVAAApFBUAACcUFQAAKBQVAAAiFhUAAFEWFwAASRgFAABQGRcAADgaGwAAKxocAAA9Gh0AAD4WHgAAFB8gAQwAFQkhAQwAFgkiAQwARyMFAQwAQSQlAQwAQCQlAQwAQiQdAQwBGkMKAQABKkIVAQACLTsdAQACU0QdAQACVQUpAQADIS4vAQADJS8pAQADTUUvAQADUzodAQAEETEFAgcEBB9HFQEHBEQ1NwIHBARFNTYCBwQFETEFAgcMBRRHSgIHDAUVNUwCBwwFH0cVAQcFRDU3AgcMBh0KBQEDBxknBQAHJCAlAQgHNAAnAAdSLSUACTU8PQEACkgqGwAlKDUrJig1Ci4wKjIECi00MjAqNDM4BwosNCkoJygjKC0yOAoJCiIdIR0kKCgoMUYrSCtJLzAwMAEHCBACCAAIAQMIAAgBBwgQAQsKAQgNAwcIAAYIAQYIEAADBwgABggBBQMHCAAGCAEJAAQHCAAGCAEGCw4BCQAJAAMHCAAGCAEICwEJAAQHCAAGCAEICwMEBwgABggBCQADAwcIAAgLCwoBCA0CCQALDwEJAAUHCAAGCAEICwMHCBABCwIBCQADBwgACwIBCQALCgEIDQIHCAALAgEJAAQHCAAGCAELCAEDBwgQAgYIAAgLAQECBwgABggBAQcIDAMHCAAGCAEBAQcIAAEGCAABBQEOAQMBBwsJAQgNAwYIAAYIAQgLAQYJAAEHCQACCQAIAwMHCAAJAAgDAQYLAgEJAAEICwIIAQgAAQgMAQgNAQsJAQkAAQYIEAEIAAUIDAgLCAwOCwkBCA0BBggMAgsJAQkABwgQAQsKAQkAAggECQADBwgMCQAJAQIIBgEDCAsICwgLAggFAwIHCAwJAAELCAEJAQEJAQELBwEJAAIJAAMBBgsKAQkAAgcLCQEJAAsJAQkAAwgLAwgLAQsPAQkABggLCAwICwgLAwgMBQgMCAsICwMDAwgMCAsICwMDAwMBBgsIAQkAAQsIAQkAAQYLCQEJAAMHCwkBCQADBwgQAQgEAgYIDAkAAQgGAQgFAQYJAQIICwgLAQcJAQdCYWxhbmNlBkJvcnJvdwRDb2luAklEBEl0ZW0KSXRlbUxpc3RlZAVLaW9zaw1LaW9za093bmVyQ2FwB0xpc3RpbmcETG9jawZPcHRpb24LUHVyY2hhc2VDYXADU1VJDlRyYW5zZmVyUG9saWN5D1RyYW5zZmVyUmVxdWVzdAlUeENvbnRleHQDVUlEA2FkZBBhbGxvd19leHRlbnNpb25zB2JhbGFuY2UGYm9ycm93CmJvcnJvd19tdXQKYm9ycm93X3ZhbBJjbG9zZV9hbmRfd2l0aGRyYXcEY29pbgZkZWxldGUMZGVzdHJveV9zb21lDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQEZW1pdAVldmVudAdleGlzdHNfA2Zvcgxmcm9tX2JhbGFuY2UKaGFzX2FjY2VzcwhoYXNfaXRlbQJpZAxpbnRvX2JhbGFuY2UMaXNfZXhjbHVzaXZlCWlzX2xpc3RlZBVpc19saXN0ZWRfZXhjbHVzaXZlbHkJaXNfbG9ja2VkB2lzX3NvbWUKaXRlbV9jb3VudAdpdGVtX2lkBGpvaW4Fa2lvc2sIa2lvc2tfaWQEbGlzdBZsaXN0X3dpdGhfcHVyY2hhc2VfY2FwBGxvY2sJbWluX3ByaWNlA25ldwtuZXdfcmVxdWVzdAZvYmplY3QGb3B0aW9uBW93bmVyBXBsYWNlDnBsYWNlX2FuZF9saXN0BXByaWNlB3Byb2ZpdHMOcHJvZml0c19hbW91bnQLcHJvZml0c19tdXQIcHVyY2hhc2URcHVyY2hhc2VfY2FwX2l0ZW0ScHVyY2hhc2VfY2FwX2tpb3NrFnB1cmNoYXNlX2NhcF9taW5fcHJpY2URcHVyY2hhc2Vfd2l0aF9jYXAGcmVtb3ZlEHJlbW92ZV9pZl9leGlzdHMTcmV0dXJuX3B1cmNoYXNlX2NhcApyZXR1cm5fdmFsBnNlbmRlchRzZXRfYWxsb3dfZXh0ZW5zaW9ucwlzZXRfb3duZXIQc2V0X293bmVyX2N1c3RvbQNzdWkEdGFrZQ90cmFuc2Zlcl9wb2xpY3kKdHhfY29udGV4dAd1aWRfbXV0EHVpZF9tdXRfYXNfb3duZXIMdWlkX3RvX2lubmVyBXZhbHVlCHdpdGhkcmF3BHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMICgAAAAAAAAADCAsAAAAAAAAAAAIFJAgMPAsJAQgNOAUrDhIBAQICJAgMIAgLAgIEJAgMLwgLLAgLMwMDAgIvCAssCAsEAgEkCAsFAgIkCAsmAQYCASQICwcCAy4ICyQICzsDBwoCCgABAAAmEwoAETY4AAoALhE5SQAAAAAIEgAMAgsAETYOAjgBEgEMAQsCCwECAQEAACwmCwATAAEMBgEMBwwFCwETAQwEDAMOBRE3CwQhBBEFFQsCAQcAJwsGSQAAAAAhBBoFHgsCAQcDJwsDETQLBRE0CwcLAjgCAgIBAAAFFQoALjgBCwEQABQhBAkFDwsAAQsCAQcAJwsCETkLAA8BFQIDAQAABRIKAC44AQsBEAAUIQQJBQ0LAAEHACcLAgsADwEVAgQBAAAFHQoALjgBCwEQABQhBAkFDQsAAQcAJwoAEAIUSQEAAAAWCgAPAhULAA8DDgI4AxIECwI4BAIFAQAABQwKAA8DDgM4AxIGCDgFCwALAQsDOAYCBgEAADNICgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ8gBBYFGgsAAQcIJwoACgIMBC4LBBERIAQjBScLAAEHBCcKAAoCDAUuCwURDgQvBTMLAAEHCycKABACFEkBAAAAFwoADwIVCgAPAwoCCRIFOAcBCwAPAwsCEgQ4CAIHAQAAJSkKAC44AQsBEAAUIQQJBQ0LAAEHACcKAAoCDAQuCwQRESAEFgUaCwABBwQnCgAPAwoCCRIFCgM4CQsALjgBCwILAzkAOAoCCAEAACUNDgI4AwwECgAKAQsCOAYLAAsBCwQLAzgLAgkBAAA5MwoADwMKAQkSBTgMDAQKAA8DCgESBDgIDAMKABACFEkBAAAAFwoADwIVCgQOAjgNIQQbBR8LAAEHAScKAA8ECwI4DjgPAQoADwMKARIGOBABCwMLAQsECwAuOAE4EQIKAQAAPjwKAC44AQoBEAAUIQQJBRELAAELBAELAQEHACcKAAoCDAUuCwURECAEGgUiCwABCwQBCwEBBwYnCwQRNgwKCwAPAwoCCBIFCgM4CQsKDAYLAgwHCwEQABQMCAsDDAkLBgsICwcLCTkBAgsBAAA/MgsBOgEMBgwEDAUMAw4COA0MBwoHCwYmBA4FEgsAAQcBJwoALjgBCwUhBBkFHQsAAQcFJwoADwMKBAgSBTgMAQoADwMKBAkSBQsHOAkLAxE0CwALBAsCOBICDAEAAEAbCwE6AQEMAwwEDAIKAC44AQsEIQQNBRELAAEHBScLAA8DCwMIEgU4DAELAhE0Ag0BAABBMQoALjgBCwEQABQhBAkFDwsAAQsDAQcAJw4COBMEJQsCOBQMBgoGCgAQBDgVJQQcBSILAAELAwEHAicLBgwEBSkKABAEOBUMBAsEDAULAA8ECwULAzgWAg4BAAAFBgsAEAMLARIEOBcCDwEAAAUGCwAQAwsBEgY4GAIQAQAAFRIKABADCgEJEgU4GQQMCwABCAwCBRALAAsBEREMAgsCAhEBAAAFBwsAEAMLAQgSBTgZAhIBAAAFCAsALjgBCwEQABQhAhMBAAAFEAoALjgBCwEQABQhBAkFDQsAAQcAJwsADwMCFAEAAAUSCgAuOAELARAAFCEECQUNCwABBwAnCwILAA8FFQIVAQAABQwKABAFFAQFBQkLAAEHBycLAA8DAhYBAAAFBAsAEAEUAhcBAAAFBAsAEAIUAhgBAAAFBAsAEAQ4FQIZAQAABRAKAC44AQsBEAAUIQQJBQ0LAAEHACcLAA8EAhoBAAAFGwoAOAELARAAFCEECAUMCwABBwAnCgAKAhEOBBEFFQsAAQcLJwsAEAMLAhIEOBoCGwEAAEssCgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ4EFQUZCwABBwsnCgAKAgwELgsEERAgBCIFJgsAAQcJJwsADwMLAhIEOBsCHAEAAEsxCgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ4EFQUZCwABBwsnCgAKAgwELgsEERAgBCIFJgsAAQcJJwoADwMKAhIEOAgLAC44AQsCEgMCHQEAAEsgCwITAwwDDAQKAC44AQsEIQQLBQ8LAAEHBScOATgDCgMhBBUFGQsAAQcKJwsADwMLAxIECwE4BAIeAQAABQQLADcAFAIfAQAABQQLADcBFAIgAQAABQQLADcCFAIBAQACAAMAAAABAAQCAQICAgMGCgcKCAoABXRhYmxlggahHOsLBgAAAA0BAAgCCBADGHMEiwEKBZUBaAf9AacBCKQDIAbEAwoKzgMIC9YDAgzYA+UBDb0FBA7BBQQAEwAKABAAFAAADAIHAQQBAgIEAAMBAgAADwABAgcEAAMCAwIHBAAEBAUCBwQABQYHAgcEABEGCAIHBAAGBAkCBwQADgoLAgcEAA0KCQIHBAAIAQMCBwQACQEDAgcGAQMOAwIHBAEEDwUCBwQBBRAHAgcEAQsPCQIHBAEREAgCBwQCBwwDAAIPAAwACg0LDQwNDg0NDQEHCAIBCwACCQAJAQMHCwACCQAJAQkACQEAAgYLAAIJAAkBCQABBgkBAgcLAAIJAAkBCQABBwkBAQkBAQEBBgsAAgkACQEBAwEIAQIJAAkBAwcIAQkACQECBggBCQACBwgBCQACCAEDBVRhYmxlCVR4Q29udGV4dANVSUQDYWRkBmJvcnJvdwpib3Jyb3dfbXV0CGNvbnRhaW5zBmRlbGV0ZQ1kZXN0cm95X2VtcHR5BGRyb3ANZHluYW1pY19maWVsZBBleGlzdHNfd2l0aF90eXBlAmlkCGlzX2VtcHR5Bmxlbmd0aANuZXcGb2JqZWN0BnJlbW92ZQRzaXplBXRhYmxlCnR4X2NvbnRleHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAAAAgIMCAESAwANAAEAAAMFCwAREAYAAAAAAAAAADkAAgEBAAADDgoANgALAQsCOAAKADcBFAYBAAAAAAAAABYLADYBFQICAQAAAwULADcACwE4AQIDAQAAAwULADYACwE4AgIEAQAACA8KADYACwE4AwwCCgA3ARQGAQAAAAAAAAAXCwA2ARULAgIFAQAAAwULADcACwE4BAIGAQAAAwQLADcBFAIHAQAAAwYLADcBFAYAAAAAAAAAACECCAEAABEOCwA6AAwCDAELAgYAAAAAAAAAACEECQULBwAnCwERDwIJAQAAAwULADoAAREPAgAAAAEADQENAAV0eXBlc2ihHOsLBgAAAAYBAAIDAgYFCAYHDhoIKCAMSAQAAQAAAAEBAgEGCQABARNpc19vbmVfdGltZV93aXRuZXNzBXR5cGVzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQIAAAZib3Jyb3f+BKEc6wsGAAAADQEACAIIGAMgOwRbCgVlUwe4AZ4BCNYCQAaWAxQKqgMTC70DAgy/A30NvAQEDsAEBAAFAQ8ADgATAAMEAQwAAAAAAAECBwEAAAIBBwADBAIAAAwAAQEMAAUCAwEMABAEBQEMAAYBBgEMAQcJBgEAAQgLBgEAAQkPBQEAARIGCQEAAgsMDQEIAwoHCAAHBgUGCAYGBgQGAgkABwgEAQsAAQkAAQcLAAEJAAIJAAgBAwcLAAEJAAkACAEAAQkAAQcIBAEFAQsCAQkAAggDCQABBwsCAQkAAQYJAAEIAwIIAwUCBwsCAQkACQAGQm9ycm93AklEBk9wdGlvbghSZWZlcmVudAlUeENvbnRleHQGYm9ycm93B2Rlc3Ryb3kMZGVzdHJveV9zb21lB2V4dHJhY3QEZmlsbBRmcmVzaF9vYmplY3RfYWRkcmVzcwJpZANuZXcDb2JqBm9iamVjdAZvcHRpb24IcHV0X2JhY2sDcmVmBHNvbWUKdHhfY29udGV4dAV2YWx1ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAACAgsFFAsCAQkAAQICEQUNCAMABgABAAAFBgsBEQkLADgAOQACAQEAAAoOCgA2ADgBDAIOAjgCDAELAgsANwEUCwESAQICAQAADh4LAhMBDAMMBA4BOAILAyEECgUOCwABBwEnCgA3ARQLBCEEFQUZCwABBwAnCwA2AAsBOAMCAwEAAAkHCwA6AAwBAQsBOAQCAAEAAAAGAQYABm9iamVjdLcIoRzrCwYAAAAMAQAIAggMAxR+BJIBBgWYASMHuwH6Agi1BEAG9QRwCuUFCwzwBYICDfIHBA/2BwgAGAEEAAMAHgAABwAAAgQAAwECAAAVAAEAABQAAgAAEwEDAAASAgMAABsEBQAACAYFAAAfBwAAACIHAwAAIQcBAAAgBwIAABYIBQAACQUGAAAPCQMBCAAFCQABCAARCQEBCAAQCQIBCAAGCQcBCAAXAgUAAAoCBgAAGQIGAAEcCQEBAAIOAQIAAw0IAgADGgQCABQCEAoUAwEGCAABCgIBBQEIAAEGCAIBCAEAAQYIAQEHCAIBBgkAAQkAAklECVR4Q29udGV4dANVSUQHYWRkcmVzcwNiY3MJYm9ycm93X2lkCmJvcnJvd191aWQFYnl0ZXMFY2xvY2sGZGVsZXRlC2RlbGV0ZV9pbXBsDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQUZnJlc2hfb2JqZWN0X2FkZHJlc3MKZnJvbV9ieXRlcwJpZAppZF9hZGRyZXNzCGlkX2J5dGVzD2lkX2Zyb21fYWRkcmVzcw1pZF9mcm9tX2J5dGVzDWlkX3RvX2FkZHJlc3MLaWRfdG9fYnl0ZXMDbmV3EW5ld191aWRfZnJvbV9oYXNoBm9iamVjdA5yZWNvcmRfbmV3X3VpZAZzZW5kZXIQc3VpX3N5c3RlbV9zdGF0ZQh0b19ieXRlcwh0cmFuc2Zlcgp0eF9jb250ZXh0DHVpZF9hc19pbm5lcg51aWRfdG9fYWRkcmVzcwx1aWRfdG9fYnl0ZXMMdWlkX3RvX2lubmVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwgAAAAAAAAAAAUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEHBQECAQ8IAAABAAAGBAsAEAA4AAIBAQAABgQLABAAFAICAQAABgQLABEVEQMCAwEAAAYDCwASAAIEAAAABgwLABEXBwMhBAYFCAcCJwcAEgASAQIFAwAABgQHARIAEgECBgEAAAYDCwAQAQIHAQAABgQLABABFAIIAQAABgULABABEAA4AAIJAQAABgULABABEAAUAgoBAAAGBQsAERYSABIBAgsBAAAGBQsAEwETABESAgwBAAAGBQsAOAEQARQCDQEAAAYECwA4ARABAg4BAAAGBQsAOAEQATgCAg8BAAAGBgsAOAEQARAAFAIQAAIAEQMAAAYGCgAREwsAEgASAQISAAIAEwACAAAAAQAACAALAAwAHQAGcHJvdmVyXaEc6wsGAAAABAEAAgcCBwgJIAYpHgAABnByb3ZlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAAdhZGRyZXNzygOhHOsLBgAAAAkBAAoCCggDEj0ETwIFURQHZYEBCOYBQAamAjYM3AJFAAEBAgEDAQsACAEABwADAAcAAA8AAQAABwEAAAAGAgAAAA0AAgAADAADAAAOAAQAAAkFBgAACgUBAAELAgMAAg0HAgEAAwUDBAAEBAICAAkAAQUBDwEKAgEIAAEIAQABAwEGCQAGU3RyaW5nB2FkZHJlc3MFYXNjaWkDYmNzBmVuY29kZQpmcm9tX2FzY2lpCmZyb21fYnl0ZXMJZnJvbV91MjU2A2hleAZsZW5ndGgDbWF4BnN0cmluZw90b19hc2NpaV9zdHJpbmcIdG9fYnl0ZXMJdG9fc3RyaW5nB3RvX3UyNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwggAAAAAAAAAA8g//////////////////////////////////////////8DCAAAAAAAAAAAAAECAAEBAgACAQIAAwEAAAUDDgA4AAIEAQAABQULABEDEQsRCAIFAQAABQQLABEEEQoCBgEAAAUCBwACBwEAAAUCBwECAAdiYWxhbmNlyAehHOsLBgAAAA4BAAQCBBADFFMEZwIFaWMHzAHgAQisAyAGzANKCpYECgugBAQMpATbAg3/BgQOgwcED4cHAgADABAAAQQBAAEAAAQBAAEBAgIAABEAAQEAAA8CAQEAAAUDBAECAAoFBgEAAAYHAQEAABMIBgEAAAsJAQEAAA0KBgEAABILBgEAAAkGCAEAAAQMBgEAAAcNCAEAAAgEAQEAAQwODwAHAwEGCwEBCQABAwEGCwABCQABCQABCwABCQACBwsAAQkAAwELAQEJAAIHCwABCQALAQEJAAACBwsBAQkACwEBCQACBwsBAQkAAwEHCwEBCQACAwYIAgILAQEJAAYIAgEGCAIBBQdCYWxhbmNlBlN1cHBseQlUeENvbnRleHQHYmFsYW5jZRZjcmVhdGVfc3Rha2luZ19yZXdhcmRzDWNyZWF0ZV9zdXBwbHkPZGVjcmVhc2Vfc3VwcGx5F2Rlc3Ryb3lfc3RvcmFnZV9yZWJhdGVzDmRlc3Ryb3lfc3VwcGx5DGRlc3Ryb3lfemVybw9pbmNyZWFzZV9zdXBwbHkEam9pbgZzZW5kZXIFc3BsaXQDc3VpDHN1cHBseV92YWx1ZQp0eF9jb250ZXh0BXZhbHVlDHdpdGhkcmF3X2FsbAR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAREDAQIBEQMAAwEDAAEAAAgECwA3ABQCAQEAAAgECwA3ARQCAgEAAAgDBgAAAAAAAAAAOQACAwEAAAgYCgEG//////////8KADcBFBcjBAkFDQsAAQcBJwoANwEUCgEWCwA2ARULATkBAgQBAAABGAsBOgEMAgoANwEUCgImBAoFDgsAAQcBJwoANwEUCgIXCwA2ARULAgIFAQAACAMGAAAAAAAAAAA5AQIGAQAAAQ8LAToBDAIKADcAFAsCFgoANgAVCwA3ABQCBwEAAAgWCgA3ABQKASYEBwULCwABBwInCgA3ABQKARcLADYAFQsBOQECCAEAAAEICgA3ABQMAQsACwE4AAIJAQAACA0OADcAFAYAAAAAAAAAACEEBwUJBwAnCwA6AQECCgAAAAgLCwERDQcEIQQGBQgHAycLADkBAgsAAAAIDAsBEQ0HBCEEBgUIBwMnCwA6AQECDAMAAAgDCwA6AAIBAAAAAAMBAwAOAAdkaXNwbGF55gqhHOsLBgAAAA0BABACEC4DPoQBBMIBFgXYAcQBB5wD3wII+wVABrsGFArPBiYL9QYGDPsGoAMNmwoGDqEKBgAOAR8AEgAaABsAIAAhACQAAAwBCAEAAQMBCAEACAMBCAEBBAcAAwIHAAMGBAAEAwwABgUCAAcHBwIBAAAAABgAAQEIABkCAQEIAAwAAwEIACMEAwEIAAkFAwEIAAsGAwEIAA8FAwEIAB0HAwEIABcICQEIACUKCwEIABMKDAEIAA0NAQEIAAoFAwEIAhAOAwEDAxgNHAADIhUWAAQUCAkBAAUcEwMBDAYeERIABxEDHgIBAAcWHwMCAQAHHRobAgEACA4LDgAODA4RAQ0XFRkQDg0dExkUGQIGCAYHCAcBCwABCQAEBggGCggDCggDBwgHAAEHCwABCQADBwsAAQkACAMIAwMHCwABCQAKCAMKCAMCBwsAAQkACAMBBggGAQEBBgsAAQkAAQ0BBgsIAggDCAMBBwgHAQkAAwsAAQkAAwMBCAMBBggHAQUCCQAFAg0LCAIIAwgDAQYIBQEIBAELAgEJAAIDAwIIAwgDAgcLCAIJAAkBBgkAAgkACQEBCAUBCwEBCQABCwgCCQAJAQMHCwgCCQAJAQkACQEHRGlzcGxheQ5EaXNwbGF5Q3JlYXRlZAJJRAlQdWJsaXNoZXIGU3RyaW5nCVR4Q29udGV4dANVSUQGVmVjTWFwDlZlcnNpb25VcGRhdGVkA2FkZAxhZGRfaW50ZXJuYWwMYWRkX211bHRpcGxlD2NyZWF0ZV9hbmRfa2VlcA9jcmVhdGVfaW50ZXJuYWwHZGlzcGxheQRlZGl0BGVtaXQFZW1wdHkFZXZlbnQGZmllbGRzDGZyb21fcGFja2FnZQJpZAZpbnNlcnQNaXNfYXV0aG9yaXplZANuZXcPbmV3X3dpdGhfZmllbGRzBm9iamVjdAdwYWNrYWdlD3B1YmxpY190cmFuc2ZlcgZyZW1vdmUGc2VuZGVyBnN0cmluZwh0cmFuc2Zlcgp0eF9jb250ZXh0DHVpZF90b19pbm5lcg51cGRhdGVfdmVyc2lvbgd2ZWNfbWFwB3ZlcnNpb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAAAAgMVCAUTCwgCCAMIAyUNAQIBFQgEAgIDFQgEJQ0TCwgCCAMIAwIOAQ4ADgABAAADCwsAOAAEBAUICwEBBwAnCwE4AQIBAQAADysOAUEQDAYKBg4CQRAhBAkFDwsAAQsDAQcBJwYAAAAAAAAAAAwFCwALAzgCDAQKBQoGIwQpBRoNBA4BCgVCEBQOAgoFQhAUOAMLBQYBAAAAAAAAABYMBQUVCwQCAgEEAAMICwAKATgCCwEuERI4BAIDAQQAFBgKADcAFEgBABYKADYAFQoANwAUDAEKADcBFAwCCwA3AhEPCwELAjkAOAUCBAEEAAMFCwALAQsCOAMCBQEEABgmDgFBEAwECgQOAkEQIQQJBQ0LAAEHAScGAAAAAAAAAAAMAwoDCgQjBCMFFAoADgEKA0IQFA4CCgNCEBQ4AwsDBgEAAAAAAAAAFgwDBQ8LAAECBgEEAAMLCgA2AQ4BOAYBAQsACwELAjgDAgcBBAADBwsANgEOATgGAQECCAEAAAMDCwA4BwIJAQAAAwQLADcAFAIKAQAAAwMLADcBAgsAAAAcDAsAEQ4MAQ4BEQ85ATgICwE4CUgAADkCAgwAAAADBgsANgELAQsCOAoCAAIAAQAAAA4BDgIOAAdlZDI1NTE5aqEc6wsGAAAABgEAAgMCBQUHDAcTFwgqIAxKBAAAAAEAAQADBgoCBgoCBgoCAQEHZWQyNTUxOQ5lZDI1NTE5X3ZlcmlmeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAAHZ3JvdGgxNs0GoRzrCwYAAAAKAQACAgIQAxIyBURMB5AB7QII/QMgBp0EHgq7BCAM2wS0AQ2PBg4ACgAABwAAAQcAAAMHAAACBwAABQABAAAGAAEAABACAwAAEQMEAAAPBQYAAA4FBwAADAgDAAANCQMAABIKCwAAEwwLAAABCAAECgIKAgoCCgIBCAEBCgoCAQoCAQgCAQgDAgYIAAYKAgICBgoCBAYIAAYIAQYIAgYIAwEBBwIGCgIGCgIGCgIGCgIGCgIGCgIFQ3VydmUUUHJlcGFyZWRWZXJpZnlpbmdLZXkLUHJvb2ZQb2ludHMRUHVibGljUHJvb2ZJbnB1dHMWYWxwaGFfZzFfYmV0YV9nMl9ieXRlcwhibHMxMjM4MQVibjI1NAVieXRlcxVkZWx0YV9nMl9uZWdfcGNfYnl0ZXMVZ2FtbWFfZzJfbmVnX3BjX2J5dGVzB2dyb3RoMTYCaWQVcHJlcGFyZV92ZXJpZnlpbmdfa2V5HnByZXBhcmVfdmVyaWZ5aW5nX2tleV9pbnRlcm5hbBdwcm9vZl9wb2ludHNfZnJvbV9ieXRlcx5wdWJsaWNfcHJvb2ZfaW5wdXRzX2Zyb21fYnl0ZXMOcHZrX2Zyb21fYnl0ZXMMcHZrX3RvX2J5dGVzFHZlcmlmeV9ncm90aDE2X3Byb29mHXZlcmlmeV9ncm90aDE2X3Byb29mX2ludGVybmFsFXZrX2dhbW1hX2FiY19nMV9ieXRlcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAAIBCwIBAgQUCgIECgIJCgIICgICAgEHCgIDAgEHCgIAAQAAAAMxABIAAgEBAAAAAzEBEgACAgEAAAAGCwALAQsCCwMSAQIDAQAABBhABQAAAAAAAAAADAENAQ4AEAAURAUNAQ4AEAEURAUNAQ4AEAIURAUNAQ4AEAMURAULAQIEAQAAAAMLABICAgUBAAAAAwsAEgMCBgEAAAAGCwAQBBQLAREHAgcAAgAIAQAAABELABAEFAoBEAAKARABCgEQAgsBEAMLAhAFCwMQBhEJAgkAAgABAAEBAQIBAwAAAgADAAAHcGFja2FnZf8NoRzrCwYAAAALAQAOAg4kAzK3AQTpAQoF8wF2B+kC/gQI5wdABqcIXQqECTAMtAmBBA21DRQAJAEKATIAIQAwADEAMwABDAAABgwAAAgAAAAHAAABAgcAAgQHAAMABwADBQQABQMCAAAOAAEBAgAPAAIBAgAMAQIAABYDBAEAABUDBAEAACcDBQAAKAMFAAA0BgcAADYGCAAANQYJAAAuCgcAAC8KCQAAKQsHAAAqCwcAAC0KDAAAEQIJAAAJAgkAABMCCQAAIg0CAAAjDQIAAB4OAgAACw8QAAAQEQIAACsSAgACFwITAQACGBgZAAIZGBkAAxIXAgADGhUHAQgDGxsHAAMcHxsAAyAWFwAEJhwCAQwFLBobAAYdFQQBAiIUGBQAFCABHA4CCQAHCAgBCAAAAQYIAAEBAQYIBAEGCAEBCAYBAwECAQYIAgEGCAMBBgoCAQcIAQEIAQMHCAECCgIBCAICBwgBCAMCBwgBAgEIBQEJAAEGCQABBwgIAQgHAQYIBQEIBAEGCAgBBQIJAAUCAQgFAggGCAYBBggGAklECVB1Ymxpc2hlcgZTdHJpbmcJVHhDb250ZXh0CFR5cGVOYW1lA1VJRApVcGdyYWRlQ2FwDlVwZ3JhZGVSZWNlaXB0DVVwZ3JhZGVUaWNrZXQPYWRkaXRpdmVfcG9saWN5BWFzY2lpEWF1dGhvcml6ZV91cGdyYWRlDmJ1cm5fcHVibGlzaGVyA2NhcAVjbGFpbQ5jbGFpbV9hbmRfa2VlcA5jb21taXRfdXBncmFkZRFjb21wYXRpYmxlX3BvbGljeQZkZWxldGUPZGVwX29ubHlfcG9saWN5BmRpZ2VzdAtmcm9tX21vZHVsZQxmcm9tX3BhY2thZ2UDZ2V0C2dldF9hZGRyZXNzCmdldF9tb2R1bGUCaWQPaWRfZnJvbV9hZGRyZXNzDWlkX3RvX2FkZHJlc3MTaXNfb25lX3RpbWVfd2l0bmVzcw5tYWtlX2ltbXV0YWJsZQttb2R1bGVfbmFtZQNuZXcGb2JqZWN0Fm9ubHlfYWRkaXRpdmVfdXBncmFkZXMRb25seV9kZXBfdXBncmFkZXMHcGFja2FnZQZwb2xpY3kPcHVibGljX3RyYW5zZmVyEHB1Ymxpc2hlZF9tb2R1bGURcHVibGlzaGVkX3BhY2thZ2ULcmVjZWlwdF9jYXAPcmVjZWlwdF9wYWNrYWdlCHJlc3RyaWN0BnNlbmRlcg10aWNrZXRfZGlnZXN0DnRpY2tldF9wYWNrYWdlDXRpY2tldF9wb2xpY3kIdHJhbnNmZXIKdHhfY29udGV4dAl0eXBlX25hbWUFdHlwZXMPdXBncmFkZV9wYWNrYWdlDnVwZ3JhZGVfcG9saWN5B3ZlcnNpb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAACAQACAYACAcAFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDGggHJAgEHwgEAQIEGggHJAgGNgMlAgICBA0IBiQIBiUCFAoCAwICDQgGJAgGAAEAABMSDgA4AAQEBQgLAQEHACc4AQwCCwERHw4CERkOAhEaEgACAQEAAAIICwAKATgCCwEuESE4AwICAQAAAgYLABMAAQERGwIDAQAAEwk4AQwBDgERGQsAEAAUIQIEAQAAHRc4AQwCDgIRGQoAEAAUIQQRDgIRGgsAEAEUIQwBBRULAAEJDAELAQIFAQAAAgMLABABAgYBAAACAwsAEAACBwEAAAIECwAQAhQCCAEAAAIECwAQAxQCCQEAAAIECwAQBBQCCgEAAAIECwAQBRQCCwEAAAIECwAQBhQCDAEAAAIECwAQBxQCDQEAAAIECwAQCBQCDgEAAAIDCwAQCQIPAQAAAgIHBQIQAQAAAgIHBgIRAQAAAgIHBwISAQQAAgQLAAcGERcCEwEEAAIECwAHBxEXAhQBBAACBwsAEwEBAQERGwIVAQAAHikHCBEdDAMKABACFAoDIgQKBQ4LAAEHAicKAQoAEAQUJgQVBRkLAAEHAScKABACFAwECwMKAA8CFQsALjgECwQLAQsCEgICFgEAAB4nCwETAwwDDAIKAC44BAsCIQQLBQ8LAAEHBCcKABACER4HCCEEFgUaCwABBwMnCwMKAA8CFQoAEAMUBgEAAAAAAAAAFgsADwMVAhcAAAACEAoAEAQUCgElBAcFCwsAAQcBJwsBCwAPBBUCAAEAAgEBAQIBAwIBAgIDAAMBAgMAB3ZlY19tYXC4DaEc6wsGAAAADQEABgIGFgMcqAEExAEcBeAB/gEH3gOZAgj3BUAGtwYyCukGFQv+BgQMggfrBQ3tDAYO8wwGAB4BFQEfAAIHAgEAAAAAAAcCAQAAAAEBBwEAAAAHAAECAQAADgIAAgEAABcDBAIBAAAWBQQCAQAADQMGAgEAAAgHCAIBAAAcBwkCAQEAAwcKAgEAABoLDAIBAAAQCwoCAQAABQEAAgEAAA8BDQIBAAATCw4CAQAADAcPAgEAAAsHDAIBAAAJEBECAQAAChITAgEAABgSBAIBAAEGGxgBAAERHAoBAAEUABsBAAEbGBsBAAIQGQoBAAIXFxgBAAIZHwABAAcEDgQXFBYUBQQVGhQaDQQTDAgEGBQVDBQMEgwAAQsAAgkACQEDBwsAAgkACQEJAAkBAgcLAAIJAAkBBgkAAgkACQEBBwsAAgkACQEBBwkBAgYLAAIJAAkBBgkAAQYJAQELAgEJAQEBAQYLAAIJAAkBAQMCCgkACgkBAQoJAAELAgEDAgYLAAIJAAkBAwIGCQAGCQECBwsAAgkACQEDAgYJAAcJAQELAQIJAAkBAQYJAAIGCQADAgcKCQADAQkAAQYKCQABCQEBCwIBCQABBgsCAQkAAQoLAQIJAAkBBwoLAQIJAAkBAwkACgkAAwkBCgkBAQcKCQAEBgsBAgkACQEDCgkAAwIDAwEGCwECCQAJAQEHCwECCQAJAQVFbnRyeQZPcHRpb24GVmVjTWFwCGNvbnRhaW5zCGNvbnRlbnRzDWRlc3Ryb3lfZW1wdHkMZGVzdHJveV9zb21lBWVtcHR5A2dldBBnZXRfZW50cnlfYnlfaWR4FGdldF9lbnRyeV9ieV9pZHhfbXV0B2dldF9pZHgLZ2V0X2lkeF9vcHQHZ2V0X211dAZpbnNlcnQQaW50b19rZXlzX3ZhbHVlcwhpc19lbXB0eQdpc19zb21lA2tleQRrZXlzBG5vbmUGb3B0aW9uA3BvcAZyZW1vdmUTcmVtb3ZlX2VudHJ5X2J5X2lkeAdyZXZlcnNlBHNpemUEc29tZQd0cnlfZ2V0BXZhbHVlB3ZlY19tYXAGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAAIBBAoLAQIJAAkBAQICEgkAHQkBAAQBBAABAAAAA0AUAAAAAAAAAAA5AAIBAQAAFRQKAA4BDAMuCwM4ACAECQUNCwABBwAnCwA2AAsBCwI5AUQUAgIBAAAWDQoACwEMAi4LAjgBDAMLADYACwM4AjoBAgMBAAAADwoANwA4AyAEBgUKCwABBwQnCwA2AEUUOgECBAEAABYNCgALAQwCLgsCOAEMAwsANgALA0MUNgECBQEAAAwKCgALATgBDAILADcACwJCFDcBAgYBAAAJEwoACgE4AAQLCwALATgEFDgFDAIFEQsAAQsBATgGDAILAgIHAQAADwcLAAsBOAcMAg4COAgCCAEAAAAECwA3AEEUAgkBAAAABQsAOAkGAAAAAAAAAAAhAgoBAAAdDAsAOgAMAQ4BOAMEBwUJBwInCwFGFAAAAAAAAAAAAgsBAAAeKAsAOgAMAQ0BOAoGAAAAAAAAAAAMAg4BQRQMBUAYAAAAAAAAAAAMBEAaAAAAAAAAAAAMBwoCCgUjBCMFEw0BRRQ6AQwGDAMNBAsDRBgNBwsGRBoLAgYBAAAAAAAAABYMAgUOCwFGFAAAAAAAAAAACwQLBwIMAQAAICAGAAAAAAAAAAAMAgoANwBBFAwEQBgAAAAAAAAAAAwDCgIKBCMEHAUNCgA3AAoCQhQMAQ0DCwE3AhREGAsCBgEAAAAAAAAAFgwCBQgLAAELAwINAQAAISQGAAAAAAAAAAAMAgoAOAkMAwoCCgMjBB4FCgoANwAKAkIUNwIKASEEGQsAAQsBAQsCOAsCCwIGAQAAAAAAAAAWDAIFBQsAAQsBATgMAg4BAAAPDQsACwE4BwwCDgI4CAQIBQoHAScLAjgNAg8BAAAiFAoBCgA4CSMEBgUKCwABBwMnCwA3AAsBQhQMAgoCNwILAjcBAhABAAAjFQoBCgAuOAkjBAcFCwsAAQcDJwsANgALAUMUDAIKAjcCCwI2AQIRAQAAABEKAQoALjgJIwQHBQsLAAEHAycLADYACwE4AjoBAgAAAQEBAAAEAQQCBAAHdmVjX3NldK0GoRzrCwYAAAANAQAGAgYMAxJgBHIUBYYBWgfgAZ8BCP8CQAa/AxQK0wMHC9oDAgzcA5ECDe0FAg7vBQIAEgENARMAAQcBAwABAAcBAAAABQABAQMADwIBAQMACAMAAQMADgQAAQMAAgUGAQMAEAcIAQMACgcGAQMACQEJAQMABwUKAQMABgUIAQMBBBACAQABCw4GAQABDAAQAQABEQIQAQACDg0CAQACDwIJAQAPAgQCCQIOAggCCwgFAg0IDAgKCAABCwABCQABCQACBwsAAQkACQACBwsAAQkABgkAAgYLAAEJAAYJAAEBAQYLAAEJAAEDAQoJAAELAQEDAQYJAAIGCQADAgcKCQADAQYLAQEJAAIDAwELAQEJAAZPcHRpb24GVmVjU2V0CGNvbnRhaW5zCGNvbnRlbnRzDGRlc3Ryb3lfc29tZQVlbXB0eQdnZXRfaWR4C2dldF9pZHhfb3B0Bmluc2VydAlpbnRvX2tleXMIaXNfZW1wdHkHaXNfc29tZQRub25lBm9wdGlvbgZyZW1vdmUJc2luZ2xldG9uBHNpemUEc29tZQd2ZWNfc2V0BnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAACAQMKCQAAAgABAAAAA0ACAAAAAAAAAAA5AAIBAQAAAAQLADgAOQACAgEAAAsSCgAOAQwCLgsCOAEgBAkFDQsAAQcAJwsANgALAUQCAgMBAAAMDQoACwEMAi4LAjgCDAMLADYACwM4AwECBAEAAAoHCwALATgEDAIOAjgFAgUBAAAABAsANwBBAgIGAQAAAAULADgGBgAAAAAAAAAAIQIHAQAAAAMLADoAAggAAAAPIwYAAAAAAAAAAAwCCgA4BgwDCgIKAyMEHQUKCgA3AAoCQgIKASEEGAsAAQsBAQsCOAcCCwIGAQAAAAAAAAAWDAIFBQsAAQsBATgIAgkAAAAKDQsACwE4BAwCDgI4BQQIBQoHAScLAjgJAgAAAAIACGJsczEyMzgxlAGhHOsLBgAAAAYBAAIDAgoFDAwHGDgIUCAMcAgAAAACAAEAAAEAAQADBgoCBgoCBgoCAQEIYmxzMTIzODEWYmxzMTIzODFfbWluX3BrX3ZlcmlmeRdibHMxMjM4MV9taW5fc2lnX3ZlcmlmeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAEBAgAACGVjZHNhX2sx1AGhHOsLBgAAAAcBAAIDAg8FERwHLUAIbSAGjQEaDKcBDAABAAIAAQAAAAIBAAADAwQAAwYKAgYKAgIBCgIBBgoCBAYKAgYKAgYKAgIBARFkZWNvbXByZXNzX3B1YmtleQhlY2RzYV9rMRNzZWNwMjU2azFfZWNyZWNvdmVyEHNlY3AyNTZrMV92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAgEAAgEBAAECAAEBAgACAQIAAAhlY2RzYV9yMbQBoRzrCwYAAAAHAQACAwIKBQwYByQuCFIgBnIaDIwBCAAAAAEAAQAAAgIDAAMGCgIGCgICAQoCBAYKAgYKAgYKAgIBAQhlY2RzYV9yMRNzZWNwMjU2cjFfZWNyZWNvdmVyEHNlY3AyNTZyMV92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAgEAAgEBAAECAAEBAgAACHRyYW5zZmVy+AKhHOsLBgAAAAgBAAIDAjYEOAYFPggHRpABCNYBIAb2AQoMgAJSAAcABwABAQgABAABAQwAAAIBAQgAAgIBAQwABQIBAQgAAwIBAQwAAQIBAQgABgIBAQgACAABAQgIAgYCBwICCQAFAAEJAA1mcmVlemVfb2JqZWN0EmZyZWV6ZV9vYmplY3RfaW1wbBRwdWJsaWNfZnJlZXplX29iamVjdBNwdWJsaWNfc2hhcmVfb2JqZWN0D3B1YmxpY190cmFuc2ZlcgxzaGFyZV9vYmplY3QRc2hhcmVfb2JqZWN0X2ltcGwIdHJhbnNmZXINdHJhbnNmZXJfaW1wbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAABAAABBAsACwE4AAIBAQAAAQQLAAsBOAACAgEAAAEDCwA4AQIDAQAAAQMLADgBAgQBAAABAwsAOAICBQEAAAEDCwA4AgIGAwIABwMCAAgDAgAACXRhYmxlX3ZlY7IGoRzrCwYAAAANAQAGAgYSAxhnBH8UBZMBigEHnQKfAQi8AyAG3AMUCvADCgv6AwIM/AP1AQ3xBQIO8wUCABEAEAASAAEEAQQBAQAMAgcBBAECAgIAAAgAAQEEAA8CAQEEAAoDBAEEAAkDBQEEAAQGBwEEAA0ICQEEAAUKCwEEAAwMDQEEAAcBCQEEAQMTCQIHBAEEERICBwQBBRQVAgcEAQcPCQIHBAEKEAQCBwQBCwAPAgcEAQ4UFgIHBA4OAA0FDQ0OAg0KDgkOCw4PDgwOAQcIAgELAAEJAAIJAAcIAgEGCwABCQABAwEBAgYLAAEJAAMBBgkAAgcLAAEJAAkAAAIHCwABCQADAQcJAAEHCwABCQABCQACAwkAAQsBAgkACQEBBgsBAgkACQECBgsBAgkACQEJAAEGCQEDBwsBAgkACQEJAAkBAgcLAQIJAAkBCQABBwkBAQkBBVRhYmxlCFRhYmxlVmVjCVR4Q29udGV4dANhZGQGYm9ycm93CmJvcnJvd19tdXQIY29udGVudHMNZGVzdHJveV9lbXB0eQVlbXB0eQhpc19lbXB0eQZsZW5ndGgDbmV3CHBvcF9iYWNrCXB1c2hfYmFjawZyZW1vdmUJc2luZ2xldG9uBXRhYmxlCXRhYmxlX3ZlYwp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAACAQYLAQIDCQAADQABAAAJBAsAOAA5AAIBAQAAAQgLATgBDAINAgsAOAILAgICAQAACQQLADcAOAMCAwEAAAkFCwA4BAYAAAAAAAAAACECBAEAAAkPCgA4BAoBJAQGBQoLAAEHACcLADcACwE4BQIFAQAABAoKAC44BAwCCwA2AAsCCwE4BgIGAQAACRAKAC44BAoBJAQHBQsLAAEHACcLADYACwE4BwIHAQAABBQKAC44BAwBCgEGAAAAAAAAAAAkBAkFDQsAAQcAJwsANgALAQYBAAAAAAAAABc4CAIIAQAACQwOADgEBgAAAAAAAAAAIQQGBQgHAScLADoAOAkCAAAADQAJdmVyc2lvbmVk/gWhHOsLBgAAAAsBAAgCCBQDHFUEcQoFe2EH3AHsAQjIAyAG6AMKCvIDEAyCBMUBDccFBAAXAAsAEAAUAAQMAAADAAACAAcAAgIEAAMBAgAACAABAQQAFgIDAAANAgQBBAAOBQYBBAATBQcBBAAVCAkBBAAKAQoBBAEFDgkCBwQBBg8QAgcEAQcREgIHBAESERMCBwQCCQwJAAIMBBQBCAIPCwwABw0IDQkNCg0MAQMDCQAHCAQBCAABBggAAQMBBgkAAQcIAAEHCQACCQAIAQQHCAADCQAIAQABCQABBwgEAQgDAgMJAAMHCAMJAAkBAgYIAwkAAQYJAQIHCAMJAAEHCQEBCQEBCAIDCAMJAAMCSUQJVHhDb250ZXh0A1VJRBBWZXJzaW9uQ2hhbmdlQ2FwCVZlcnNpb25lZANhZGQGYm9ycm93CmJvcnJvd19tdXQGY3JlYXRlBmRlbGV0ZQdkZXN0cm95DWR5bmFtaWNfZmllbGQCaWQKbG9hZF92YWx1ZQ5sb2FkX3ZhbHVlX211dANuZXcGb2JqZWN0C29sZF92ZXJzaW9uBnJlbW92ZRhyZW1vdmVfdmFsdWVfZm9yX3VwZ3JhZGUKdHhfY29udGV4dAd1cGdyYWRlB3ZlcnNpb24JdmVyc2lvbmVkDHZlcnNpb25lZF9pZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAACAgwIAxYDAQICGAgCEQMAAQAAAQwLAhENCgASAAwDDQMPAAsACwE4AAsDAgEBAAAJBAsAEAEUAgIBAAAJBwoAEAALABABFDgBAgMBAAAJBwoADwALABABFDgCAgQBAAAJDgoADwAKABABFDgDCgAuOAQLABABFBIBAgUBAAADIAsDEwEMBAoALjgEIQQJBQ0LAAEHACcLBAoBIwQSBRYLAAEHACcKAA8ACgELAjgACwELAA8BFQIGAQAAFQwLABMADAMMAQ0BCwM4AwwCCwERCwsCAgAAAAEACm9iamVjdF9iYWfpBqEc6wsGAAAACwEACgIKFgMgfAScAQ4FqgFYB4IC5wEI6QNABqkECgqzBAgMuwT1AQ2wBgQAFAEVAAwAEwAYAAEMAAECBwEAAAMABwADBAQABAMCAAASAAEAAAUCAwIHDAAGBAUCBwwABwYHAgcMABYGCAIHDAAIBAkBBwAJBAkCBwwAEQoLAAAQCgkAAAsBAwAAGQQMAQcCBQ8DAgcMAgYQBQIHDAIHEQcCBwwCDRAJAQcCDhAJAgcMAg8QDAEHAhYRCAIHDAMKDQMAAxIADQALDgwODQ4RDg4SDw4QEgEHCAQBCAADBwgACQAJAQACBggACQABBgkBAgcIAAkAAQcJAQEJAQEBAQYIAAEDAQsBAQgCAQgDAgkACQEDBwgDCQAJAQIGCAMJAAIHCAMJAAEJAAIIAwMCSUQJT2JqZWN0QmFnBk9wdGlvbglUeENvbnRleHQDVUlEA2FkZAZib3Jyb3cKYm9ycm93X211dAhjb250YWlucxJjb250YWluc193aXRoX3R5cGUGZGVsZXRlDWRlc3Ryb3lfZW1wdHkUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlAmlkCGlzX2VtcHR5Bmxlbmd0aANuZXcGb2JqZWN0Cm9iamVjdF9iYWcGb3B0aW9uBnJlbW92ZQRzaXplCnR4X2NvbnRleHQIdmFsdWVfaWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAACAg8IAxcDAAEAAAMFCwAREwYAAAAAAAAAABIAAgEBAAADDgoADwALAQsCOAAKABABFAYBAAAAAAAAABYLAA8BFQICAQAAAwULABAACwE4AQIDAQAAAwULAA8ACwE4AgIEAQAACA8KAA8ACwE4AwwCCgAQARQGAQAAAAAAAAAXCwAPARULAgIFAQAAAwULABAACwE4BAIGAQAAAwULABAACwE4BQIHAQAAAwQLABABFAIIAQAAAwYLABABFAYAAAAAAAAAACECCQEAABMOCwATAAwCDAELAgYAAAAAAAAAACEECQULBwAnCwEREgIKAQAAAwULABAACwE4BgIAAAABAAp0eF9jb250ZXh0+QKhHOsLBgAAAAoBAAICAgQDBh4FJBQHOGgIoAEgBsABFArUAQ4M4gFgDcICCgAHAAACAAAGAAEAAAIAAgAAAwACAAAEAwEAAAUAAgAAAQQBAAEGCAABBQEDAQcIAAIKAgMAAgUDCVR4Q29udGV4dAlkZXJpdmVfaWQFZXBvY2gSZXBvY2hfdGltZXN0YW1wX21zFGZyZXNoX29iamVjdF9hZGRyZXNzC2lkc19jcmVhdGVkBnNlbmRlcgp0eF9jb250ZXh0B3R4X2hhc2gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIIAAAAAAAAAADCAAAAAAAAAAAAAIFBgUICgICAwMDBQMAAQAABQQLABAAFAIBAQAABQQLABABFAICAQAABQQLABACFAIDAQAABhIKABADFAwCCgAQBBQKAhEFDAELAgYBAAAAAAAAABYLAA8DFQsBAgQAAAAFBAsAEAMUAgUAAgAAAAACAAMABAABAAxsaW5rZWRfdGFibGWRDaEc6wsGAAAADQEACgIKHgMo1AEE/AEcBZgCvAEH1APNAgihBkAG4QYUCvUGJgubBwQMnweXBQ22DA4OxAwOABgBHQAOABwAKAAADAIHAAQBAAEEAgcABAABAgcBAAADBAQABAMCAAAZAAECBwQAEQIDAgcEAAYCAwIHBAAiBAUCBwQAIQQFAgcEAAcGBwIHBAAICAkCBwQAIAYDAgcEABoGAwIHBAAjCAoCBwQAHwsMAgcEAB4LDAIHBAAJBg0CBwQAFwIOAgcEABQCDQIHBAALAQUCBwQADQEFAgcGAQcDGQEAAQwREAEAARATBQEAARUDDQEAARYDDQEAARsFEQEAASUQEQEAASYTEQEAAgUWBQIHBAIHFwcCBwQCCBUJAgcEAg8XDQIHBAIjFQoCBwQDCg8FAAMZAA8AFhAYEBQQExAVEBIQFxAbFBkUGhQdFBEQCQwcFAEHCAQBCwACCQAJAQEGCwACCQAJAQEGCwIBCQADBwsAAgkACQEJAAkBAAIGCwACCQAJAQkAAQYJAQIHCwACCQAJAQkAAQcJAQEJAQEHCwACCQAJAQIJAAkBAQEBAwEIAwEJAAELAgEJAAULAgEJAAsCAQkACwIBCQAJAAsCAQkAAgcLAgEJAAkAAgkACwECCQAJAQIHCAMJAAMHCAMJAAkBAgYIAwkAAwsCAQkACwIBCQAJAQEGCQACCAMDC0xpbmtlZFRhYmxlBE5vZGUGT3B0aW9uCVR4Q29udGV4dANVSUQDYWRkBGJhY2sGYm9ycm93CmJvcnJvd19tdXQIY29udGFpbnMGZGVsZXRlDWRlc3Ryb3lfZW1wdHkMZGVzdHJveV9zb21lBGRyb3ANZHluYW1pY19maWVsZBBleGlzdHNfd2l0aF90eXBlBGZpbGwFZnJvbnQEaGVhZAJpZAhpc19lbXB0eQdpc19ub25lB2lzX3NvbWUGbGVuZ3RoDGxpbmtlZF90YWJsZQNuZXcEbmV4dARub25lBm9iamVjdAZvcHRpb24IcG9wX2JhY2sJcG9wX2Zyb250BHByZXYJcHVzaF9iYWNrCnB1c2hfZnJvbnQGcmVtb3ZlBHNpemUEc29tZQxzd2FwX29yX2ZpbGwEdGFpbAp0eF9jb250ZXh0BXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAAIEEwgDJAMSCwIBCQAnCwIBCQABAgMgCwIBCQAaCwIBCQApCQEADAEMAAEAAAUHCwARHwYAAAAAAAAAADgAOAA5AAIBAQAABQMLADcAAgIBAAAFAwsANwECAwEAABI2CgA2AAoBOAEMBQoANwE4AgQNCgA2AQoBOAM4AAwHDgU4BAQhCwU4BQwGCgE4BgoANgIKBjgHNgMVCwY4BgwDBSM4AAwDCwMMBAoANgILAQsHCwQLAjkBOAgKADcEFAYBAAAAAAAAABYLADYEFQIEAQAAEjYKADcAOAIECAoANgAKATgDCgA2AQoBOAEMBQ4FOAQEHwsFOAUMBgoBOAYKADYCCgY4BzYFFQsGOAYMAwUhOAAMAwsDDAc4AAwECgA2AgsBCwcLBAsCOQE4CAoANwQUBgEAAAAAAAAAFgsANgQVAgUBAAAFBgsANwILATgJNwYCBgEAAAUGCwA2AgsBOAc2BgIHAQAABQYLADcCCwE4CTcDAggBAAAFBgsANwILATgJNwUCCQEAABhBCgA2AgoBOAo6AQwEDAIMAwoANwQUBgEAAAAAAAAAFwoANgQVDgM4BAQcCgIKADYCDgM4CxQ4BzYFFQ4COAQEKAoDCgA2Ag4COAsUOAc2AxUKADcAOAsOASEEMgsCCgA2ABUKADcBOAsOASEEPQsDCwA2ARUFPwsAAQsEAgoBAAAQEwoANwA4BAQFBQkLAAEHAScKADcAOAsUDAEKAQsACwE4DAILAQAAEBMKADcBOAQEBQUJCwABBwEnCgA3ATgLFAwBCgELAAsBOAwCDAEAAAUFCwA3AgsBOA0CDQEAAAUECwA3BBQCDgEAAAUGCwA3BBQGAAAAAAAAAAAhAg8BAAAaEAsAOgABAQwCDAELAgYAAAAAAAAAACEECwUNBwAnCwERHgIQAQAABQcLADoAAQEBER4CAAIAAwAAAQAAAQEBAQIADAEMAgwDDAQMBQwGDAAMb2JqZWN0X3RhYmxl3wahHOsLBgAAAA0BAAoCChoDJHgEnAEMBagBcQeZAscBCOADQAagBAoKqgQIC7IEAgy0BOYBDZoGBA6eBgQAEgETAAsAEQAWAAEMAgcBDAEBAgcBAAADAAcAAwQEAAQDAgAAEAABAgcMAAUCAwIHDAAGBAUCBwwABwYHAgcMABQGCAIHDAAIBAkCBwwADwoLAgcMAA4KCQIHDAAKAQMCBwwAFwQMAgcMAgUPAwIHDAIGEAUCBwwCBxEHAgcMAgwQCQEHAg0QDAEHAhQRCAIHDAMJDQMAAxAADQAKDgsODA4PDg0SDhIBBwgEAQsAAgkACQEDBwsAAgkACQEJAAkBAAIGCwACCQAJAQkAAQYJAQIHCwACCQAJAQkAAQcJAQEJAQEBAQYLAAIJAAkBAQMBCwEBCAIBCAMCCQAJAQMHCAMJAAkBAgYIAwkAAgcIAwkAAQkAAggDAwJJRAtPYmplY3RUYWJsZQZPcHRpb24JVHhDb250ZXh0A1VJRANhZGQGYm9ycm93CmJvcnJvd19tdXQIY29udGFpbnMGZGVsZXRlDWRlc3Ryb3lfZW1wdHkUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXwJpZAhpc19lbXB0eQZsZW5ndGgDbmV3Bm9iamVjdAxvYmplY3RfdGFibGUGb3B0aW9uBnJlbW92ZQRzaXplCnR4X2NvbnRleHQIdmFsdWVfaWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAACAg0IAxUDAA4AAQAAAwULABERBgAAAAAAAAAAOQACAQEAAAMOCgA2AAsBCwI4AAoANwEUBgEAAAAAAAAAFgsANgEVAgIBAAADBQsANwALATgBAgMBAAADBQsANgALATgCAgQBAAAIDwoANgALATgDDAIKADcBFAYBAAAAAAAAABcLADYBFQsCAgUBAAADBQsANwALATgEAgYBAAADBAsANwEUAgcBAAADBgsANwEUBgAAAAAAAAAAIQIIAQAAEw4LADoADAIMAQsCBgAAAAAAAAAAIQQJBQsHACcLAREQAgkBAAADBQsANwALATgFAgAAAAEADgEOAA1keW5hbWljX2ZpZWxklgqhHOsLBgAAAA4BAAYCBhYDHIUBBKEBGAW5AagBB+ECgQMI4gVABqIGKArKBgwL1gYCDNgG6wINwwkGDskJCA/RCQIACwEaABkAAAgCBwAEAAECBwEAAAIBBwACAwQAAAQAAQIHBAAGAgMCBwQACQQFAgcEABsEBgIHBAANAgcBBwAdBAgCBwQADgIHAgcEAA8CCQEHABAECgEHABMLDAEHAAULAQEIAAcJDQEIAAgKDgEIABwPEAEIABEPBwAAEg8HAQgBGAEYAQABHhAYAQACChMBAAIVHAwAAhcMEwACHxIMAAkQChULFQwVDRUEEAMUEQYQBg8VCxoMGgMHCAMJAAkBAAIGCAMJAAEGCQECBwgDCQABBwkBAQkBAQEBCwEBCQECBggDBQIHCAMFAgUJAAEFAQYJAAEHCQACBQUBCQADCwACCQAJAQUFAQYIAwEIAwIJAAkBAQsAAgkACQEDBQUJAQIJAAsBAQkBAQsBAQkABAYLAAIJAAgCBQYIAwYIAgELAAIJAAgCAgkACAIBBggCBAcLAAIJAAgCBQcIAwcIAgVGaWVsZAJJRAZPcHRpb24DVUlEA2FkZBBhZGRfY2hpbGRfb2JqZWN0BmJvcnJvdxNib3Jyb3dfY2hpbGRfb2JqZWN0F2JvcnJvd19jaGlsZF9vYmplY3RfbXV0CmJvcnJvd19tdXQGZGVsZXRlDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlCmZpZWxkX2luZm8OZmllbGRfaW5mb19tdXQQaGFzX2NoaWxkX29iamVjdBhoYXNfY2hpbGRfb2JqZWN0X3dpdGhfdHkRaGFzaF90eXBlX2FuZF9rZXkCaWQNaWRfdG9fYWRkcmVzcwRuYW1lEW5ld191aWRfZnJvbV9oYXNoBG5vbmUGb2JqZWN0Bm9wdGlvbgZyZW1vdmUTcmVtb3ZlX2NoaWxkX29iamVjdBByZW1vdmVfaWZfZXhpc3RzBHNvbWUOdWlkX3RvX2FkZHJlc3MFdmFsdWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAACAxQIAxYJACAJAQAUAAEAABEaCwAuERUMBQoFCgE4AAwECgUKBBEOIAQOBRAHACcLBBEUCwELAjkADAMLBQsDOAECAQEAAAwKCgARFQsBOAAMAgsACwI4AjcAAgIBAAAMCwoALhEVCwE4AAwCCwALAjgDNgACAwEAABYRCwAuERUMAwoDCwE4AAwCCwMLAjgEOgAMBAEREgsEAgQBAAAPCwsAERUMAwoDCwE4AAwCCwMLAhEOAgUBAAAXEwoACgEMAi4LAjgFBA0LAAsBOAY4BwwDBRELAAE4CAwDCwMCBgEAAA8LCwARFQwDCgMLATgADAILAwsCOAkCBwMAABkWCgARFQsBOAAMAwsACwM4CgwCCgI3AQwECgI3AgELAjcDDAULBAsFERMCCAMAAB0YCgAuERULATgADAMLAAsDOAsMAgoCNgEMBAoCNgIBCwI2AwwFCwQLBS4REwIJAwIACgMCAAsDAgAMAwIADQMCAA4DAgAPAwIAAAIAAAABABQBGwIbABsADAAOcHJpb3JpdHlfcXVldWXQCqEc6wsGAAAADQEABAIEDAMQPARMCgVWpwEH/QG4AQi1A0AG9QMOCoMEEguVBAQMmQTzBQ2MCgQOkAoEAAsBEAABBgECAAAABgECAAAGAAEBAgAIAgMBAgAEBAUBAgAHAwYBAgACBwABAgANCAUBAgAFCQUBAgAJCgsBAgEMDw0BAAEODw0BAAYNCQYFDQgQCA0BCgsBAQkAAQsAAQkAAQcLAAEJAAIDCQADBwsAAQkAAwkAAAELAQEJAAIKAwoJAAIHCgsBAQkAAwMHCgsBAQkAAwMBBgsAAQkAAQoDAgMDAQkAAwMDCQACBwoJAAMBAwUDAwMKCwEBCQAJAAUHCgsBAQkAAwcKCwEBCQADAw0HCgsBAQkAAQMHCgsBAQkAAwEHCgsBAQkAAwcKCwEBCQADAwMDAgMKAwVFbnRyeQ1Qcmlvcml0eVF1ZXVlDmNyZWF0ZV9lbnRyaWVzB2VudHJpZXMGaW5zZXJ0FW1heF9oZWFwaWZ5X3JlY3Vyc2l2ZQNuZXcJbmV3X2VudHJ5B3BvcF9tYXgKcHJpb3JpdGllcwhwcmlvcml0eQ5wcmlvcml0eV9xdWV1ZQZyZW1vdmUWcmVzdG9yZV9oZWFwX3JlY3Vyc2l2ZQtzd2FwX3JlbW92ZQV2YWx1ZQZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAoDAQAAAgEDCgsBAQkAAQICCgMPCQAADQENAAEAAAwYDgBBBgwCCgIGAgAAAAAAAAAaDAEKAQYAAAAAAAAAACQEFQUMCwEGAQAAAAAAAAAXDAENAAoCCgE4AAUHCwA5AAIBAQAADh4KADcAQQYMAQoBBgAAAAAAAAAAJAQJBQ0LAAEHACcKADYABgAAAAAAAAAAOAE6AQwDDAILADYACwEGAQAAAAAAAAAXBgAAAAAAAAAAOAALAgsDAgIBAAAQEQoANgALAQsCOQFEBgoANwBBBgYBAAAAAAAAABcMAwsANgALAzgCAgMBAAAFBAsACwE5AQIEAQAAESgOAEEQDAMOAUENCgMhBAkFCwYAAAAAAAAAACdABgAAAAAAAAAADAUGAAAAAAAAAAAMAgoCCgMjBCYFFA0ABgAAAAAAAAAAOAMMBA0BBgAAAAAAAAAAOAQMBg0FCwQLBjkBRAYLAgYBAAAAAAAAABYMAgUPCwUCBQAAABIuCgEGAAAAAAAAAAAhBAcLAAECCgEGAQAAAAAAAAAXBgIAAAAAAAAAGgwGCgAKAQwDDAIKAAoGDAUMBAsCLgsDQgY3ARQLBC4LBUIGNwEUJAQrCgALAQoGRwYLAAsGOAIFLQsAAQIGAAAAE24KAQYAAAAAAAAAACEEBwsAAQIKAgoBIwQMBRALAAEGAQAAAAAAAAAnCgIGAgAAAAAAAAAYBgEAAAAAAAAAFgwNCg0GAQAAAAAAAAAWDA8KAgwOCg0KASMENwoACg0MBQwDCgAKDgwHDAYLAy4LBUIGNwEUCwYuCwdCBjcBFCQMCAU5CQwICwgEPQsNDA4KDwoBIwRYCgAKDwwKDAkKAAoODAwMCwsJLgsKQgY3ARQLCy4LDEIGNwEUJAwEBVoJDAQLBAReCw8MDgoOCgIiBGsKAAoOCwJHBgsACwELDjgABW0LAAECBwEAABQcBwEMAgYAAAAAAAAAAAwBCgEKADcAQQYjBBgFCw0CCgA3AAoBQgY3ARREEAsBBgEAAAAAAAAAFgwBBQQLAAELAgIAAAEAAA0BDQAPdHJhbnNmZXJfcG9saWN5+xGhHOsLBgAAAA0BABgCGE4DZvMBBNkCKgWDA5YDB5kG5QQI/gpABr4LPAr6CzcLsQwKDLsM4QQNnBEQDqwREAA7AS8BPQATABUAHAAfAC4AMAA5ADwAQgAKAAEAAQAHDAEAAQAIDAEAAQAJAwEAAQAFBwECAQEDBwEAAAIMBwADAAQBAAEEAQwBAAEHAgcABw0EAAgEDAAJBgIACgsCAAsOBwEDAAAtAAEBAAAsAgMBAABDBAUBAAAZBgUBAAAWBwABAAARCAkDAAIGACUKCwMAAgYAEgwJAgACABANCQIAAgAmDg8CAAIANhAJAwACBgA+DhEBAAA/EBIBAAArExQBAAAxExUBAAAhExQBAAEaJBgBAAEqIw8BAAIkCRYBAANBJRUBAANECR8BAAQiKScBAAQzNQkBAAQ6JicBAAUPMQkCBwQFFDM0AgcEBSAzDwEHBTU3LwIHBAYdGAkBAwcYHAkAByciFAEIBywbHAAHQBEUAAgjGg8BAAsXLQ8BAwseCRcBAwsoMgkBAwspFysBAws4LBUBAyMWIRgcHRQeHiERFRAVEx4XHhUeJRYmFiIWCS4YMBIvJBYZMBYeGjYbMAMICQMICQELAAEJAAIGCAsHCA0CCwEBCQALAgEJAAQHCwEBCQAGCwIBCQALBQEDBwgNAQsIAQgMAwsBAQkACwIBCQAHCA0CBgsBAQkACwABCQAECQEHCwEBCQAGCwIBCQAJAgACCQEGCwEBCQABBgkCAwkBBwsBAQkACwgBCAwCCQEHCwABCQABBgsBAQkAAQECBwsBAQkABgsCAQkAAQYICgEHCAoBBgsAAQkAAQgJAQMBCAYBCw4BCQABCQAFCAoLDgEIBgsHAQgMCAoICQEGCAsBBwgNAQgKAQsDAQkAAQgMAQsHAQkAAwMDAwELAQEJAAEGCQABBgsFAQkAAQsFAQkAAQYLBwEJAAMHCwcBCQADBwgNAQsIAQkAAgsHAQgMCAoCCwcBCQAHCA0HCggGCAkICQMLDgEIBggGAwEKCQABBgsOAQkAAgYLDgEJAAYJAAIJAAkBAQkBAgsEAQkBCQIDBwgKCQAJAQIHCw4BCQAJAAIGCAoJAAEGCQECBwsHAQkACwgBCQABCwQBCQECBwgKCQAHQmFsYW5jZQRDb2luAklEBk9wdGlvbglQdWJsaXNoZXIHUnVsZUtleQNTVUkOVHJhbnNmZXJQb2xpY3kRVHJhbnNmZXJQb2xpY3lDYXAVVHJhbnNmZXJQb2xpY3lDcmVhdGVkD1RyYW5zZmVyUmVxdWVzdAlUeENvbnRleHQIVHlwZU5hbWUDVUlEBlZlY1NldANhZGQLYWRkX3JlY2VpcHQIYWRkX3J1bGUOYWRkX3RvX2JhbGFuY2UHYmFsYW5jZQZib3Jyb3cEY29pbg9jb25maXJtX3JlcXVlc3QIY29udGFpbnMGZGVsZXRlFGRlc3Ryb3lfYW5kX3dpdGhkcmF3DGRlc3Ryb3lfc29tZQtkdW1teV9maWVsZA1keW5hbWljX2ZpZWxkBGVtaXQFZW1wdHkFZXZlbnQHZXhpc3RzXwRmcm9tDGZyb21fYmFsYW5jZQxmcm9tX3BhY2thZ2UDZ2V0CGdldF9ydWxlCGhhc19ydWxlAmlkBmluc2VydAlpbnRvX2tleXMHaXNfc29tZQRpdGVtA25ldwtuZXdfcmVxdWVzdAZvYmplY3QGb3B0aW9uB3BhY2thZ2UEcGFpZAlwb2xpY3lfaWQDcHV0CHJlY2VpcHRzBnJlbW92ZQtyZW1vdmVfcnVsZQVydWxlcwRzaXplA3N1aQR0YWtlD3RyYW5zZmVyX3BvbGljeQp0eF9jb250ZXh0CXR5cGVfbmFtZQN1aWQQdWlkX211dF9hc19vd25lcgx1aWRfdG9faW5uZXIFdmFsdWUHdmVjX3NldAh3aXRoZHJhdwR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAACBCsICTEDIQgJNAsOAQgGAQIDJwgKEwsHAQgMNwsOAQgGAgICJwgKMggJAwIBJwgJBAIBGwEAGAMYARgCGAQvAAEAAAkGCwALAQsCOAA5AAIBAQAAGSALADgBBAQFCAsBAQYAAAAAAAAAACcKAREfDAUOBREgDAYKBjkBOAILBQwCOAAMAzgDDAQLAgsECwM5AgsBER8LBjkDAgIBAAAgMQoALjgECwE3ABQhBAkFDwsAAQsDAQcEJw4COAUEJQsCOAYMBgoGCgA3ATgHJQQcBSILAAELAwEHBScLBgwEBSkKADcBOAcMBAsEDAULADYBCwULAzgIAgMBAAAoGw4AOAQOATcAFCEECAUMCwIBBwQnCwE6AwEMBAsAOgIBDAMRHQsEER0LAwsCOAkCBAEAACo0CwE6AAwGDAMMBQwECwY4CgwCDgJBFgwICggKADcCOAshBBMFFwsAAQcAJwoIBgAAAAAAAAAAJAQuBRwNAkUWDAcKADcCDgc4DAQlBSkLAAEHAScLCAYBAAAAAAAAABcMCAUXCwABCwQLBQsDAgUBAAAJIgoBLjgECwI3ABQhBAkFDQsBAQcEJwoBLjgNIAQTBRcLAQEHAycKATYDCTkECwM4DgsBNgI4DzgQAgYBAAAJBgsBNwMJOQQ4EQIHAQAACQ4KAS44DQQFBQkLAQEHAicLATYBCwI4EgIIAQAACQULATYEOA84EAIJAQAACQYLADcDCTkEOBMCCgEAAAkUCgAuOAQLATcAFCEECQUNCwABBwQnCwA2Awk5BDgUAQILAQAACQMLADcDAgwBAAAJEAoALjgECwE3ABQhBAkFDQsAAQcEJwsANgMCDQEAAAkECwA3BRQCDgEAAAkECwA3BhQCDwEAAAkECwA3BxQCAgEBAQECAQAAAwAAAAEAAgAYARgCGAMYBBgFGAYYBxgAFGR5bmFtaWNfb2JqZWN0X2ZpZWxk2QehHOsLBgAAAAoBAAgCCBQDHIoBBKYBGgXAAYMBB8MCsgII9QRACrUFBgu7BQIMvQXpAQALARYACgAVAAMHAQAAAQEHAQAAAwAHAAMCBAAABAABAgcMAAYCAwIHDAAJBAUCBwwAFwQGAgcMAAwCBwEHAA0CBwIHDAARAggBBwEUARgBAAEZChgBAAIEAAECBwQCBRIBAQgCBw8LAQgCCBMUAQgCDQIHAgcEAg4CDwEHAg8EEwEHAhAWBwEIAhcEBgIHBAIYFgoBCAMRCwwBCAMSEQwAAxoQEQATBgkNDg4KBgsGDw4MBhIGEQ0NDRAGBwwIDAMHCAMJAAkBAAIGCAMJAAEGCQECBwgDCQABBwkBAQkBAQEBCwEBCAIDCwABCQAIAgsAAQkAAQkAAQYJAAEIAgILAAEJAAgCAQsAAQkAAgYIAwUBBggDAQUCBQkAAgcIAwUBBwkABAsAAQkACwABCQAJAQUCBQUCCwABCQAFAQsBAQkAAklEBk9wdGlvbgNVSUQHV3JhcHBlcgNhZGQQYWRkX2NoaWxkX29iamVjdAZib3Jyb3cTYm9ycm93X2NoaWxkX29iamVjdBdib3Jyb3dfY2hpbGRfb2JqZWN0X211dApib3Jyb3dfbXV0DWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlCmZpZWxkX2luZm8OZmllbGRfaW5mb19tdXQYaGFzX2NoaWxkX29iamVjdF93aXRoX3R5AmlkD2lkX2Zyb21fYWRkcmVzcwRuYW1lBG5vbmUGb2JqZWN0Bm9wdGlvbgZyZW1vdmUTcmVtb3ZlX2NoaWxkX29iamVjdARzb21lDnVpZF90b19hZGRyZXNzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQACARMJAAAKAAEAAAkVCwE5AAwFDgI4AAwECgAKBQsEOAELAAsFDAMuCwM4AgERFQsCOAMCAQEAAA4ICwE5AAwCCwALAjgCOAQCAgEAAA4ICwE5AAwCCwALAjgFOAYCAwEAABUUCwE5AAwDCgAKAwwCLgsCOAIMBREVCwU4BwwECwALAzgIAQsEAgQBAAAOBwsBOQAMAgsACwI4CQIFAQAAFxQLATkADAIKAAoCOAkgBAwLAAEJAgsACwI4AgwDERULAzgKAgYBAAAXFQsBOQAMAgoACgI4CSAEDAsAATgLAgsACwI4AgwDAQsDERQ4DAIANwp0eF9jb250ZXh0CVR4Q29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdAJJRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdANVSUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDYmFnA0JhZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2JhbGFuY2UGU3VwcGx5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHYmFsYW5jZQdCYWxhbmNlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDYmNzA0JDUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBmJvcnJvdwhSZWZlcmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBmJvcnJvdwZCb3Jyb3cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVjbG9jawVDbG9jawAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3VybANVcmwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luBENvaW4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luDENvaW5NZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBGNvaW4LVHJlYXN1cnlDYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luD0N1cnJlbmN5Q3JlYXRlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3ZlY19tYXAGVmVjTWFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHdmVjX21hcAVFbnRyeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3BhY2thZ2UJUHVibGlzaGVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQpVcGdyYWRlQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQ1VcGdyYWRlVGlja2V0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQ5VcGdyYWRlUmVjZWlwdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2Rpc3BsYXkHRGlzcGxheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2Rpc3BsYXkORGlzcGxheUNyZWF0ZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdkaXNwbGF5DlZlcnNpb25VcGRhdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIUZHluYW1pY19vYmplY3RfZmllbGQHV3JhcHBlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2dyb3RoMTYFQ3VydmUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdncm90aDE2FFByZXBhcmVkVmVyaWZ5aW5nS2V5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHZ3JvdGgxNhFQdWJsaWNQcm9vZklucHV0cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2dyb3RoMTYLUHJvb2ZQb2ludHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgd2ZWNfc2V0BlZlY1NldAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3N1aQNTVUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg90cmFuc2Zlcl9wb2xpY3kPVHJhbnNmZXJSZXF1ZXN0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5DlRyYW5zZmVyUG9saWN5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5EVRyYW5zZmVyUG9saWN5Q2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5FVRyYW5zZmVyUG9saWN5Q3JlYXRlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD3RyYW5zZmVyX3BvbGljeQdSdWxlS2V5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sFS2lvc2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zaw1LaW9za093bmVyQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sLUHVyY2hhc2VDYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawZCb3Jyb3cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawRJdGVtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sHTGlzdGluZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBWtpb3NrBExvY2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawpJdGVtTGlzdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMbGlua2VkX3RhYmxlC0xpbmtlZFRhYmxlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMbGlua2VkX3RhYmxlBE5vZGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgpvYmplY3RfYmFnCU9iamVjdEJhZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDG9iamVjdF90YWJsZQtPYmplY3RUYWJsZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDnByaW9yaXR5X3F1ZXVlDVByaW9yaXR5UXVldWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg5wcmlvcml0eV9xdWV1ZQVFbnRyeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBXRhYmxlBVRhYmxlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJdGFibGVfdmVjCFRhYmxlVmVjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJdmVyc2lvbmVkCVZlcnNpb25lZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCXZlcnNpb25lZBBWZXJzaW9uQ2hhbmdlQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAAAAAAAAAyA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAQAAAAAAAAALB2dlbmVzaXOAE6Ec6wsGAAAACwEAGgIaOgNUawS/AQ4FzQGwAgf9A4kJCIYNYAbmDRQK+g1dDNcO2wMNshIYAB8BLAFIAhICFAIrAj0CQgA2AD8AQABDAEYAAwMAAAIDAAAJAAAACAAAAQQHAQAAAwAEAQABBAEMAQABBQsEAAYFAgAHCgIACAYEAAoHBAALDAQAABYAAQAADwIBAAAOAwEAARkZGgEAASQYDgEAAiMWDgEAAxoJAQEAAzUICQEAA0sBCQEABB0eHwEABkEgAQAHGwUGAAgWERIACRYTAQAKFw8QAAsNIgEACyoMCgALNB0BAAwgGxwADCINDgAHBwgHBRUEFwMXCQcGBwYIBwsFAQgICAEKCAAIAgcICQAECwUBCAgKCAMHCggMBwgJAQcKCAwZCggDAwMKAgMDCgIKAgoCCgIKAgoCCgIKAgoCCAoDCwUBCAgLBQEICAUICwgMCggMCgIKAgEGCAkBAwEICAIHCwUBCQADAQsFAQkAAQgMAQgAEAUKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIDAwcICQIGCggMBggMAQEIAwMDAwMDAwcICQEICwULBQEICAMDDQcICQEICggIBwoIDAsFAQgIAwMICwgKBwgJBQsFAQgIAwULBAEFBQEIAwEGCgkAAQUBBgsEAQkAAQsEAQkAAQkAAgcKCAwFAQcIDAQHCAwLBQEICAUHCAkCCwUBCQAHCAkBCwYBCQACCwYBCAgFAgMDAgcIDAMHQmFsYW5jZQRDb2luFkdlbmVzaXNDaGFpblBhcmFtZXRlcnMYR2VuZXNpc1ZhbGlkYXRvck1ldGFkYXRhBk9wdGlvbgNTVUkMU3Rha2VTdWJzaWR5EFN5c3RlbVBhcmFtZXRlcnMPVG9rZW5BbGxvY2F0aW9uGVRva2VuRGlzdHJpYnV0aW9uU2NoZWR1bGUJVHhDb250ZXh0A1VJRAlWYWxpZGF0b3IIYWN0aXZhdGUTYWN0aXZhdGVfdmFsaWRhdG9ycw9hbGxvY2F0ZV90b2tlbnMLYWxsb2NhdGlvbnMLYW1vdW50X21pc3QHYmFsYW5jZRhjaGFpbl9zdGFydF90aW1lc3RhbXBfbXMEY29pbg9jb21taXNzaW9uX3JhdGUGY3JlYXRlGGNyZWF0ZV9zeXN0ZW1fcGFyYW1ldGVycwtkZXNjcmlwdGlvbgxkZXN0cm95X3NvbWUMZGVzdHJveV96ZXJvBWVwb2NoEWVwb2NoX2R1cmF0aW9uX21zDGZyb21fYmFsYW5jZQlnYXNfcHJpY2UHZ2VuZXNpcxFnZXRfdmFsaWRhdG9yX211dAlpbWFnZV91cmwWaXNfZHVwbGljYXRlX3ZhbGlkYXRvcghpc19lbXB0eQdpc19zb21lE21heF92YWxpZGF0b3JfY291bnQbbWluX3ZhbGlkYXRvcl9qb2luaW5nX3N0YWtlBG5hbWUPbmV0d29ya19hZGRyZXNzEm5ldHdvcmtfcHVibGljX2tleQNuZXcGb2JqZWN0Bm9wdGlvbgtwMnBfYWRkcmVzcw9wcmltYXJ5X2FkZHJlc3MLcHJvamVjdF91cmwTcHJvb2Zfb2ZfcG9zc2Vzc2lvbhNwcm90b2NvbF9wdWJsaWNfa2V5EHByb3RvY29sX3ZlcnNpb24RcmVjaXBpZW50X2FkZHJlc3MccmVxdWVzdF9hZGRfc3Rha2VfYXRfZ2VuZXNpcwVzcGxpdA1zdGFrZV9zdWJzaWR5G3N0YWtlX3N1YnNpZHlfZGVjcmVhc2VfcmF0ZRdzdGFrZV9zdWJzaWR5X2Z1bmRfbWlzdClzdGFrZV9zdWJzaWR5X2luaXRpYWxfZGlzdHJpYnV0aW9uX2Ftb3VudBtzdGFrZV9zdWJzaWR5X3BlcmlvZF9sZW5ndGgZc3Rha2Vfc3Vic2lkeV9zdGFydF9lcG9jaBVzdGFrZWRfd2l0aF92YWxpZGF0b3IDc3VpC3N1aV9hZGRyZXNzCnN1aV9zeXN0ZW0Wc3VpX3N5c3RlbV9zdGF0ZV9pbm5lcgh0cmFuc2Zlcgp0eF9jb250ZXh0CXZhbGlkYXRvciB2YWxpZGF0b3JfbG93X3N0YWtlX2dyYWNlX3BlcmlvZB12YWxpZGF0b3JfbG93X3N0YWtlX3RocmVzaG9sZA12YWxpZGF0b3Jfc2V0InZhbGlkYXRvcl92ZXJ5X2xvd19zdGFrZV90aHJlc2hvbGQGdmVjdG9yDndvcmtlcl9hZGRyZXNzEXdvcmtlcl9wdWJsaWNfa2V5BHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAACDycKAhgKAiEKAi8KAj4FHgMVAzEKAjAKAikKAkoKAigKAi0KAi4KAkkKAgECDDIDEwMcAzsDOQM6AzcNJQMmA0UDRwNEAwICAjgDEAoIAwMCAzMFEQM8CwQBBQAAAAAEkwEKBS4RCwYAAAAAAAAAACEEBwULCwUBBwAnCwQTAgwGDBYNAQsWOAAMGDgBDBdACgAAAAAAAAAADBwOA0ELDAgGAAAAAAAAAAAMCwoLCggjBFkFIQ4DCgtCCxQTAAwdDBEMEAwODB4MDwwTDBQMBwwKDBkMEgwMDAkMDQsZCxQLDwseCxMLDQsJCwwLEgsOCxALEQsdCwoLBwoFERAMGw4cDhsREyAETQVRCwUBBwEnDRwLG0QKCwsGAQAAAAAAAAAWDAsFHAsBCwYNHAoFEQENHBECDgIQABQOAhABFA4CEAIUDgIQAxQOAhAEFA4CEAUUDgIQBhQKBREODBoLGA4CEAcUDgIQCBQOAhAJFAoFEQwMFQsACxwLFw4CEAoUDgIQCxQLGgsVCwURDQIBAAAAFCwOATgCIAQjBQUNAUUVEwMMBwwFDAYNAAsFOAAMBA4HOAMEHQsHOAQMCAoCCwgREgsECwYKAxERBSILBAoDOAULBhEKBQALAgELAwELAUYVAAAAAAAAAAALADgGAgIAAAAhGAoALkEKDAEGAAAAAAAAAAAMAgoCCgEjBBUFCwoACgJDCgYAAAAAAAAAABEPCwIGAQAAAAAAAAAWDAIFBgsAAQIBAgEDAQcBCAEJAQoBCwEEAQUBBgEAAQEACXZhbGlkYXRvctI8oRzrCwYAAAAMAQAfAh9IA2e3BASeBSYFxAXwAwe0CckTCP0cYAbdHaoBCocfnAEMoyCpGw3MOzwPiDwNAIYBARQBFwFJAWcCFQIWAiICRwJoAm8CgwEAZQCIAQAOBAAADQQAAAgDAAALAwABCQcAAwMHAQAABAkHAAUADAAGAQQBAAEIAgcACQUCAAoKAgALDAcADAQHAAwGCAAMBwwADQ8CAAA3AAEAADUCAwAAGgQFAAAQBAUAABIGBQAAVgcFAABXBwUAAFoIBQAAWQkFAABeCQUAAFgEBQAAXQQFAAAdCgUAAFILBQAALgwNAAAwDA4AAGkMDwAAMQwQAAAeDBAAACkMEQAAUwwRAAAzDBAAAEoMEAAATwwQAACOAQwQAABVDBIAAFQMEgAANAwSAACPAQwSAAA9DBMAAD8MEwAAQAwTAABEDBMAAEIMFAAAQQwUAAA+DBQAAEUMFAAASAwVAAA7DBYAAG4MFgAAYgwWAABtDBYAAI0BDBYAAF8EBQAASwwWAABMDBYAACYMFgAAGQwWAABOFxgAAGYMGQAAKhoNAAAsGw0BAAArHA0BAAA5CwUAAHodBQAAeB0FAAB5HQUAAIIBHQUAAHsdBQAAcR0FAAB9HQUAAHMdBQAAfh0FAAB0HQUAAIABHQUAAHYdBQAAfx4FAAB1HgUAAHwdBQAAch0FAACBAR0FAAB3HQUAAB8GBQAAhAEOBQAAhQEfBQAANiADAAFnHyYAAmw+HwEAAxhAPgEAAyRDMwEAAy1ADQEAAy9ADQEAA0YFIgEAA2AzIgEABCUmIwAFNSgpAAaLAS0WAQAHIDMFAQMIKD4ZAQgKIS4WAApcLg8ACzgfJwAMESoFAAwbKgUADBw6BQAMLjANAAw1KD0ADEswFgAMTDAWAAxOPBgADFExBQAMUjsFAAxWLwUADFo2FgAMYTUWAAxjNRYADGowFgANOUIZAA2MATg5AFIfUiNWLFcyVzdYPTQjNB8zIzMfUDNOM1MjUx9RI08jUR9PH00BDgUKAgoCCgIKAggGCAYIDAgMCAYIBggGCAYIBwEIABAFCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCAwMHCAsBCAECBwgBAwABBwgBBAcIAQsIAQgKBQcICwMHCAEIDgcICwMHCAEIEAMCBwgBCwgBCAoCBwgBBwgLAQYIAQEBAQYIAAEFAQYIBgEGCAwBBgoCAQYLBQEIBgEGCwUBCgIBBggJAQMCBggBAwEIDQEICQIGCAEGCAECBgsFAQkABgkAAgYLBQEJAAYLBQEJAAIHCAEKAgMHCAEKAgoCAQoCBAgAAwMHCAsWBQgGCAYIBggGCwUBCgILBQEKAgsFAQoCCwUBCgILBQEIBgsFAQgGCgILBQEIBgsFAQgGCAcKAgoCCgIIBggGCAwIDAELBQEJAAEIBggBAQEBAQEBCAABAgEIBAEIDAEHCAsBCAcCBwgPAwIDAwEICgEGCwgBCQABBggLBQcIDwsIAQgKBQMHCAsBBggPAQcIDwEIAgEJAAQDAwMDAQYIDgMHCA8IDgcICwEIAwEGCBABBgUCBwgPCwgBCAoCBwgPBwgLAgYIDwMBCA8BBgkAHQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQYLBQEJAAIBAQIFBwgLAQcLBQEJAAMICQgPBQNCYWcHQmFsYW5jZQJJRAZPcHRpb24VUG9vbFRva2VuRXhjaGFuZ2VSYXRlA1NVSQlTdGFrZWRTdWkLU3Rha2luZ1Bvb2wTU3Rha2luZ1JlcXVlc3RFdmVudAZTdHJpbmcJVHhDb250ZXh0FVVuc3Rha2luZ1JlcXVlc3RFdmVudANVcmwJVmFsaWRhdG9yEVZhbGlkYXRvck1ldGFkYXRhFVZhbGlkYXRvck9wZXJhdGlvbkNhcAhhY3RpdmF0ZRVhY3RpdmF0ZV9zdGFraW5nX3Bvb2waYWRqdXN0X3N0YWtlX2FuZF9nYXNfcHJpY2UGYW1vdW50BWFzY2lpA2JhZwdiYWxhbmNlA2JjcwZib3Jyb3cPY29tbWlzc2lvbl9yYXRlCmRlYWN0aXZhdGUXZGVhY3RpdmF0ZV9zdGFraW5nX3Bvb2wPZGVwb3NpdF9yZXdhcmRzFWRlcG9zaXRfc3Rha2VfcmV3YXJkcwtkZXNjcmlwdGlvbhplZmZlY3R1YXRlX3N0YWdlZF9tZXRhZGF0YQRlbWl0BWVwb2NoBWV2ZW50DGV4dHJhX2ZpZWxkcwdleHRyYWN0CmZyb21fYXNjaWkJZ2FzX3ByaWNlB2dlbmVzaXMCaWQJaW1hZ2VfdXJsDGlzX2R1cGxpY2F0ZQ1pc19lcXVhbF9zb21lF2lzX2VxdWFsX3NvbWVfYW5kX3ZhbHVlB2lzX25vbmUMaXNfcHJlYWN0aXZlB2lzX3NvbWUIbWV0YWRhdGEEbmFtZQtuZXRfYWRkcmVzcw9uZXR3b3JrX2FkZHJlc3MUbmV0d29ya19wdWJrZXlfYnl0ZXMDbmV3EW5ld19mcm9tX21ldGFkYXRhDG5ld19tZXRhZGF0YRVuZXdfdW5zYWZlX2Zyb21fYnl0ZXMzbmV3X3VudmVyaWZpZWRfdmFsaWRhdG9yX29wZXJhdGlvbl9jYXBfYW5kX3RyYW5zZmVyGm5leHRfZXBvY2hfY29tbWlzc2lvbl9yYXRlFG5leHRfZXBvY2hfZ2FzX3ByaWNlFm5leHRfZXBvY2hfbmV0X2FkZHJlc3MabmV4dF9lcG9jaF9uZXR3b3JrX2FkZHJlc3MfbmV4dF9lcG9jaF9uZXR3b3JrX3B1YmtleV9ieXRlcxZuZXh0X2Vwb2NoX3AycF9hZGRyZXNzGm5leHRfZXBvY2hfcHJpbWFyeV9hZGRyZXNzHm5leHRfZXBvY2hfcHJvb2Zfb2ZfcG9zc2Vzc2lvbiBuZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleV9ieXRlcxBuZXh0X2Vwb2NoX3N0YWtlGW5leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MebmV4dF9lcG9jaF93b3JrZXJfcHVia2V5X2J5dGVzBG5vbmUGb2JqZWN0EG9wZXJhdGlvbl9jYXBfaWQGb3B0aW9uC3AycF9hZGRyZXNzFHBlbmRpbmdfc3Rha2VfYW1vdW50HXBlbmRpbmdfc3Rha2Vfd2l0aGRyYXdfYW1vdW50B3Bvb2xfaWQhcG9vbF90b2tlbl9leGNoYW5nZV9yYXRlX2F0X2Vwb2NoD3ByaW1hcnlfYWRkcmVzcxBwcmluY2lwYWxfYW1vdW50FXByb2Nlc3NfcGVuZGluZ19zdGFrZSRwcm9jZXNzX3BlbmRpbmdfc3Rha2VzX2FuZF93aXRoZHJhd3MLcHJvamVjdF91cmwTcHJvb2Zfb2ZfcG9zc2Vzc2lvbhVwcm90b2NvbF9wdWJrZXlfYnl0ZXMRcmVxdWVzdF9hZGRfc3Rha2UccmVxdWVzdF9hZGRfc3Rha2VfYXRfZ2VuZXNpcxtyZXF1ZXN0X3NldF9jb21taXNzaW9uX3JhdGUVcmVxdWVzdF9zZXRfZ2FzX3ByaWNlFnJlcXVlc3Rfd2l0aGRyYXdfc3Rha2UNcmV3YXJkX2Ftb3VudAZzZW5kZXIdc2V0X2NhbmRpZGF0ZV9jb21taXNzaW9uX3JhdGUXc2V0X2NhbmRpZGF0ZV9nYXNfcHJpY2UQc2V0X3ZvdGluZ19wb3dlcgRzb21lFnN0YWtlX2FjdGl2YXRpb25fZXBvY2gMc3Rha2VfYW1vdW50EXN0YWtlZF9zdWlfYW1vdW50DnN0YWtlcl9hZGRyZXNzDHN0YWtpbmdfcG9vbA9zdGFraW5nX3Bvb2xfaWQGc3RyaW5nA3N1aQtzdWlfYWRkcmVzcwtzdWlfYmFsYW5jZRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyCHRvX2J5dGVzC3RvdGFsX3N0YWtlEnRvdGFsX3N0YWtlX2Ftb3VudAp0eF9jb250ZXh0D3Vuc3Rha2luZ19lcG9jaCB1cGRhdGVfY2FuZGlkYXRlX25ldHdvcmtfYWRkcmVzcx91cGRhdGVfY2FuZGlkYXRlX25ldHdvcmtfcHVia2V5HHVwZGF0ZV9jYW5kaWRhdGVfcDJwX2FkZHJlc3MgdXBkYXRlX2NhbmRpZGF0ZV9wcmltYXJ5X2FkZHJlc3MgdXBkYXRlX2NhbmRpZGF0ZV9wcm90b2NvbF9wdWJrZXkfdXBkYXRlX2NhbmRpZGF0ZV93b3JrZXJfYWRkcmVzcx51cGRhdGVfY2FuZGlkYXRlX3dvcmtlcl9wdWJrZXkSdXBkYXRlX2Rlc2NyaXB0aW9uEHVwZGF0ZV9pbWFnZV91cmwLdXBkYXRlX25hbWUhdXBkYXRlX25leHRfZXBvY2hfbmV0d29ya19hZGRyZXNzIHVwZGF0ZV9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5HXVwZGF0ZV9uZXh0X2Vwb2NoX3AycF9hZGRyZXNzIXVwZGF0ZV9uZXh0X2Vwb2NoX3ByaW1hcnlfYWRkcmVzcyF1cGRhdGVfbmV4dF9lcG9jaF9wcm90b2NvbF9wdWJrZXkgdXBkYXRlX25leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MfdXBkYXRlX25leHRfZXBvY2hfd29ya2VyX3B1YmtleRJ1cGRhdGVfcHJvamVjdF91cmwDdXJsEXZhbGlkYXRlX21ldGFkYXRhFXZhbGlkYXRlX21ldGFkYXRhX2Jjcwl2YWxpZGF0b3IRdmFsaWRhdG9yX2FkZHJlc3MNdmFsaWRhdG9yX2NhcA12YWxpZGF0b3Jfc2V0EXZhbGlkYXRvcl93cmFwcGVyBXZhbHVlHnZlcmlmaWVkX29wZXJhdGlvbl9jYXBfYWRkcmVzcwx2b3RpbmdfcG93ZXIOd29ya2VyX2FkZHJlc3MTd29ya2VyX3B1YmtleV9ieXRlcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAMIBgAAAAAAAAADCAcAAAAAAAAAAwgIAAAAAAAAAAMICQAAAAAAAAADCAoAAAAAAAAAAwgLAAAAAAAAAAMIDAAAAAAAAAADCGQAAAAAAAAAAwhlAAAAAAAAAAMIECcAAAAAAAADCAABAAAAAAAAAAIWaQVVCgI0CgKPAQoCVAoCMQgGHggGKQgMUwgMMggGSggGTwgGjgEIBkILBQEKAkELBQEKAj4LBQEKAkULBQEKAjwLBQEIBj8LBQEIBkALBQEIBkQLBQEIBiMIBwECCjAIAI0BA0gICSYDZQgPGQNDAzsDOgMjCAcCAgVNCAmHAQVkBSEDEwMDAgdNCAmHAQVkBWEDcANQA1sDAAMAACFECwAMDgsBDBkLAgwdCwMMHgsEDB8LBQwgCwYMIQsHDCILCAwjCwkMDwsKDBALCwwRCwwMEjgADBM4AAwUOAAMFTgADBY4AQwXOAEMGDgBDBo4AQwbCw0MHAsOCxkLHQseCx8LIAshCyILIwsPCxALEQsSCxMLFgsUCxULFwsYCxoLGwscEgACAQMAACSAAQ4JQSUHECUECw4KQSUHECUMEAUNCQwQCxAEFQ4LQSUHECUMEQUXCQwRCxEEHw4MQSUHECUMEgUhCQwSCxIEKQ4FQSUHECUMEwUrCQwTCxMEMw4GQSUHECUMFAU1CQwUCxQEPQ4HQSUHECUMFQU/CQwVCxUERw4IQSUHECUMFgVJCQwWCxYETAVQCw8BBwknCg4HDyUEVQVZCw8BBwgnCwALAQsCCwMLBAsFEUwRVAsGEUwRVAsHEVsLCBFbCwkRTBFUCwoRTBFUCwsRTBFUCwwRTBFUCg8RVREADBcOFxFJCxcLDQsOCw8RSwICAwAABQULAA8ACwERXQIDAwAABQULAA8ACwERXAIEAwAABQ0KABABFAoADwIVCgAQAxQLAA8EFQIFAwAAKzkOATgCDAQKBAYAAAAAAAAAACQECAUOCwABCwMBBwsnCgMuEVkGAQAAAAAAAAAWDAUKAA8ACwEKAgsFCgMRZgoAEAARXwQiCgAPABFkCgAQBRQKBBYKAA8FFQoALhExCwAQBhAHFAsCCwMuEVkLBBICOAMCBgMAABYuCgMuEVkGAAAAAAAAAAAhBAcFDQsAAQsDAQcMJw4BOAIMBAoEBgAAAAAAAAAAJAQVBRsLAAELAwEHCycKAA8ACwELAgYAAAAAAAAAAAsDEWYKAA8AEWQKABAFFAsEFgsADwUVAgcDAAA0Kw4BEWkMAw4BEWgMBQoADwALAQoCEWcMBgoGCgMXDAQKABAFFAsGFwoADwUVCgAuETELABAGEAcUCgIuEVoLBQsCLhFZCwMLBBIDOAQCCAMAAAUTDgERbBQKABAGEAcUIQQKBQ4LAAEHDicLAgsADwEVAgkDAAAFIAoALhEOBAUFCQsAAQcKJw4BEWwUCgAQBhAHFCEEEwUXCwABBw4nCgIKAA8BFQsCCwAPAhUCCgMAAAUOCgEHDyUEBQUJCwABBwgnCwELAA8DFQILAwAABRcKAC4RDgQFBQkLAAEHCicKAQcPJQQOBRILAAEHCCcLAQsADwQVAgwDAAAFDgoAEAUUDgE4AhYKAA8FFQsADwALARFeAg0DAAAFEAoADwALARFlCgAuESgLABAFFCEEDQUPBwsnAg4BAAAFBAsAEAARXwIPAQAABQMLABAGAhABAAAFBQsAEAYQBxQCEQEAAAUECwAQBhAIAhIBAAAFBAsAEAYQCQITAQAABQQLABAGEAoCFAEAAAUECwAQBhALAhUBAAAFBAsAEAYQDAIWAQAABQQLABAGEA0CFwEAAAUECwAQBhAOAhgBAAAFBAsAEAYQDwIZAQAABQQLABAGEBACGgEAAAUECwAQBhARAhsBAAAFBAsAEAYQEgIcAQAABQQLABAGEBMCHQEAAAUECwAQBhAUAh4BAAAFBAsAEAYQFQIfAQAABQQLABAGEBYCIAEAAAUECwAQBhAXAiEBAAAFBAsAEAYQGAIiAQAABQQLABAGEBkCIwEAAAUECwAQBhAaAiQBAAAFBAsAEAYQGwIlAQAABQMLABAcAiYBAAAFBAsAEAEUAicBAAAFBSgLABAAEWoCKAEAAAUECwAQABFqAikBAAAFAwsAESgCKgEAAAUECwAQHRQCKwMAAAUFCwELAA8dFQIsAQAABQQLABAAEWECLQEAAAUECwAQABFiAi4BAAAFBAsAEAIUAi8BAAAFBAsAEAQUAjABAAAFBQsAEAALARFjAjEBAAAFBAsAEAA4BQIyAQAAP5cDCgAQBhAHFAoBEAYQBxQhBA0IDAIFFwoAEAYQCBQKARAGEAgUIQwCCwIEHAgMDQUmCgAQBhAMFAoBEAYQDBQhDA0LDQQrCAwYBTUKABAGEA0UCgEQBhANFCEMGAsYBDoIDBkFRAoAEAYQEBQKARAGEBAUIQwZCxkESQgMGgVTCgAQBhASFAoBEAYQEhQhDBoLGgRYCAwbBWIKABAGEBIUCgEQBhATFCEMGwsbBGcIDBwFcQoAEAYQExQKARAGEBMUIQwcCxwEdggMHQWAAQoAEAYQExQKARAGEBIUIQwdCx0EhQEIDB4FjQEKABAGEBQKARAGEBQ4BgweCx4EkgEIDAMFmgEKABAGEBUKARAGEBU4BgwDCwMEnwEIDAQFpwEKABAGEBgKARAGEBg4BwwECwQErAEIDAUFtAEKABAGEBoKARAGEBo4BwwFCwUEuQEIDAYFwQEKABAGEBoKARAGEBs4BwwGCwYExgEIDAcFzgEKABAGEBsKARAGEBs4BwwHCwcE0wEIDAgF2wEKABAGEBsKARAGEBo4BwwICwgE4AEIDAkF6AEKABAGEBQKARAGEAw4CAwJCwkE7QEIDAoF9QEKABAGEBUKARAGEA04CAwKCwoE+gEIDAsFggIKABAGEBgKARAGEBA4CQwLCwsEhwIIDAwFjwIKABAGEBoKARAGEBI4CQwMCwwElAIIDA4FnAIKABAGEBoKARAGEBM4CQwOCw4EoQIIDA8FqQIKABAGEBsKARAGEBM4CQwPCw8ErgIIDBAFtgIKABAGEBsKARAGEBI4CQwQCxAEuwIIDBEFwwIKARAGEBQKABAGEAw4CAwRCxEEyAIIDBIF0AIKARAGEBUKABAGEA04CAwSCxIE1QIIDBMF3QIKARAGEBgKABAGEBA4CQwTCxME4gIIDBQF6gIKARAGEBoKABAGEBI4CQwUCxQE7wIIDBUF9wIKARAGEBoKABAGEBM4CQwVCxUE/AIIDBYFhAMKARAGEBsKABAGEBM4CQwWCxYEjQMLAAELAQEIDBcFlQMLARAGEBsLABAGEBI4CQwXCxcCMwAAAA0RCgA4CgQKCwEBCwABCQwCBQ8LADgLCwEhDAILAgI0AAAAQRoKADgKBAYIDAIFCQoBOAoMAgsCBBILAQELAAEJDAMFGAsAOAsLATgLIQwDCwMCNQMAAA8ZCgEuEVoMAgoCCgAQBhAHFCEEDAUSCwABCwEBBw0nCwILARFrCwAPHBUCNgMAAAUSDgFBJQcQJQQGBQoLAAEHCScLARFMEVQLAA8GDwgVAjcDAAAFEg4BQSUHECUEBgUKCwABBwknCwERTBFUCwAPBg8JFQI4AwAABREOAUElBxAlBAYFCgsAAQcJJwsBEVsLAA8GDwoVAjkDAAAFEQ4BQSUHECUEBgUKCwABBwknCwERWwsADwYPCxUCOgMAAAUWDgFBJQcQJQQGBQoLAAEHCScLARFMEVQ4DAoADwYPFBULABAGEUkCOwMAAAUeCgAuEQ4EBQUJCwABBwonDgFBJQcQJQQPBRMLAAEHCScLARFMEVQKAA8GDwwVCwAQBhFJAjwDAAAFFg4BQSUHECUEBgUKCwABBwknCwERTBFUOAwKAA8GDxUVCwAQBhFJAj0DAAAFHgoALhEOBAUFCQsAAQcKJw4BQSUHECUEDwUTCwABBwknCwERTBFUCgAPBg8NFQsAEAYRSQI+AwAABRYOAUElBxAlBAYFCgsAAQcJJwsBEUwRVDgMCgAPBg8WFQsAEAYRSQI/AwAABR4KAC4RDgQFBQkLAAEHCicOAUElBxAlBA8FEwsAAQcJJwsBEUwRVAoADwYPDhULABAGEUkCQAMAAAUWDgFBJQcQJQQGBQoLAAEHCScLARFMEVQ4DAoADwYPFxULABAGEUkCQQMAAAUeCgAuEQ4EBQUJCwABBwonDgFBJQcQJQQPBRMLAAEHCScLARFMEVQKAA8GDw8VCwAQBhFJAkIDAAAFEAsBOA0KAA8GDxgVCwI4DQoADwYPGRULABAGEUkCQwMAAAUXCgAuEQ4EBQUJCwABBwonCwEKAA8GDxAVCwIKAA8GDxEVCwAQBhFJAkQDAAAFCgsBOA0KAA8GDxoVCwAQBhFJAkUDAAAFEgoALhEOBAUFCQsAAQcKJwsBCgAPBg8SFQsAEAYRSQJGAwAABQoLATgNCgAPBg8bFQsAEAYRSQJHAwAABRIKAC4RDgQFBQkLAAEHCicLAQoADwYPExULABAGEUkCSAMAAAWPAQoALhEdOA4EEgoADwYPFDgPCgAPBg8MFTgBCgAPBg8UFQoALhEeOA4EJAoADwYPFTgPCgAPBg8NFTgBCgAPBg8VFQoALhEfOA4ENgoADwYPFjgPCgAPBg8OFTgBCgAPBg8WFQoALhEgOA4ESAoADwYPFzgPCgAPBg8PFTgBCgAPBg8XFQoALhEhOBAEZwoADwYPGDgRCgAPBg8QFTgACgAPBg8YFQoADwYPGTgRCgAPBg8RFTgACgAPBg8ZFQoALhEjOBAEeQoADwYPGjgRCgAPBg8SFTgACgAPBg8aFQoALhEkOBAEjAEKAA8GDxs4EQoADwYPExU4AAsADwYPGxUFjgELAAECSQEAAAUECwA4EhFKAkoBAgBLAAAARBgOABAHFAwGCgMRYAwFCwYKAxFrDAQLAAYAAAAAAAAAAAsECgELBQoCBgAAAAAAAAAACwELAgsDEVUSAQIBBAEHAQMBCAEFAQYBAAAAAAUABgAHAAgACQAKAAsADAABAAQAAgADABEAEgATABQADQAOAA8AEAECAQEAJwBrAIkBAIoBAI0BAApzdWlfc3lzdGVt2BuhHOsLBgAAAAwBABwCHD4DWpIDBOwDCgX2A54DB5QHvwwI0xNgBrMUNgrpFAgM8RSmBg2XGwQPmxsCADABHAIQAhICFAIbAi8CMwI0AC0ALgAxAEkASgAGCAABAgcBAAACAAQBAAEDAQwBAAEFCwQABgMCAAgKAgAJBAQACgUIAAsHBAALCAQACwkEAAwNBAANDAwAABMAAQAAIgIBAAAkAwEAACEDAQAAIwMBAAAmBAEAACsEAQAAJQUBAAAqBQEAAB8GAQAAIAcBAAAnCAEAAB4JAQAANQkBAAAoAwEAAD8KAQAAPQoBAAA+CgEAAEcKAQAAQAoBAAA2CgEAAEIKAQAAOAoBAABDCgEAADkKAQAARQoBAAA7CgEAAEQLAQAAOgsBAABGCgEAADwKAQAAQQoBAAA3CgEAAA8MDQAAGQ4PAAAaDhAAABgOEAAEDhYBAgcEBBEnKwIHBAQdJygCBwQHLBgBAQgIKSMkAAsPJQ0ACxMSEwALFgEUAAseIAEACx8dAQALIB4BAAshGgEACyIZAQALIxoBAAskGgEACyUcAQALJhsBAAsnHwEACygaAQALKhwBAAsrGwEACzIPFAALNSABAAs2IQEACzchAQALOCEBAAs5IQEACzoiAQALOyEBAAs8IQEACz0hAQALPiEBAAs/IQEAC0AhAQALQSEBAAtCIQEAC0MhAQALRCIBAAtFIQEAC0YhAQALRyEBAAtIEykAJRUoFycVJSomKggIBAoIDAsCAQgFAwMICwgHBwgGABAHCAAKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIDAwcIBgIHCAAHCAYDBwgABggNAwMHCAADBwgGBAcIAAsDAQgFBQcIBgUHCAAKCwMBCAULAQEDBQcIBgMHCAAICAcIBgMHCAAGCA0FAwcIAAoCBggGBAcIAAoCCgIGCAYLCwIBCAULAgEIBQcIAAMDAwMDAwMHCAYBCwIBCAUBBwgAAQYICgEHCAoDCAAICQMHCggMCwIBCAUDAwgLCAcHCAYBCAkBAwIDCAkDBwgECQAJAQEIAAEJABAHCAoKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIDAwcIBgIHCAoHCAYDBwgKBggNAwMHCAoDBwgGBAcICgsDAQgFBQcIBgUHCAoKCwMBCAULAQEDBQcIBgMHCAoICAcIBgMHCAoGCA0FAwcICgoCBggGBAcICgoCCgIGCAYBBggGAQULBwgKAwMLAgEIBQsCAQgFAwMDAwMHCAYCBwgKCAoCBwgECQABCQEBCAoCAwgKAQcJAQdCYWxhbmNlBENvaW4GT3B0aW9uA1NVSQxTdGFrZVN1YnNpZHkJU3Rha2VkU3VpDlN1aVN5c3RlbVN0YXRlE1N1aVN5c3RlbVN0YXRlSW5uZXIVU3VpU3lzdGVtU3RhdGVJbm5lclYyEFN5c3RlbVBhcmFtZXRlcnMJVHhDb250ZXh0A1VJRB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwCVZhbGlkYXRvcgNhZGQNYWR2YW5jZV9lcG9jaAdiYWxhbmNlCmJvcnJvd19tdXQEY29pbgZjcmVhdGUNZHluYW1pY19maWVsZAdnZW5lc2lzHGdlbmVzaXNfc3lzdGVtX3N0YXRlX3ZlcnNpb24CaWQYbG9hZF9pbm5lcl9tYXliZV91cGdyYWRlEWxvYWRfc3lzdGVtX3N0YXRlFWxvYWRfc3lzdGVtX3N0YXRlX211dAZvYmplY3QGb3B0aW9uBnJlbW92ZRByZXBvcnRfdmFsaWRhdG9yEXJlcXVlc3RfYWRkX3N0YWtlGnJlcXVlc3RfYWRkX3N0YWtlX211bF9jb2luFXJlcXVlc3RfYWRkX3ZhbGlkYXRvch9yZXF1ZXN0X2FkZF92YWxpZGF0b3JfY2FuZGlkYXRlGHJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvciJyZXF1ZXN0X3JlbW92ZV92YWxpZGF0b3JfY2FuZGlkYXRlG3JlcXVlc3Rfc2V0X2NvbW1pc3Npb25fcmF0ZRVyZXF1ZXN0X3NldF9nYXNfcHJpY2UWcmVxdWVzdF93aXRoZHJhd19zdGFrZRRyb3RhdGVfb3BlcmF0aW9uX2NhcAZzZW5kZXInc2V0X2NhbmRpZGF0ZV92YWxpZGF0b3JfY29tbWlzc2lvbl9yYXRlIXNldF9jYW5kaWRhdGVfdmFsaWRhdG9yX2dhc19wcmljZQxzaGFyZV9vYmplY3QNc3Rha2Vfc3Vic2lkeQxzdGFraW5nX3Bvb2wDc3VpCnN1aV9zeXN0ZW0Wc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchRzeXN0ZW1fc3RhdGVfdmVyc2lvbgh0cmFuc2Zlcgp0eF9jb250ZXh0FXVuZG9fcmVwb3J0X3ZhbGlkYXRvcip1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9uZXR3b3JrX2FkZHJlc3MpdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfbmV0d29ya19wdWJrZXkmdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcDJwX2FkZHJlc3MqdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcHJpbWFyeV9hZGRyZXNzKnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3Byb3RvY29sX3B1YmtleSl1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl93b3JrZXJfYWRkcmVzcyh1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl93b3JrZXJfcHVia2V5HHVwZGF0ZV92YWxpZGF0b3JfZGVzY3JpcHRpb24adXBkYXRlX3ZhbGlkYXRvcl9pbWFnZV91cmwVdXBkYXRlX3ZhbGlkYXRvcl9uYW1lK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9uZXR3b3JrX2FkZHJlc3MqdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5J3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wMnBfYWRkcmVzcyt1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfcHJpbWFyeV9hZGRyZXNzK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wcm90b2NvbF9wdWJrZXkqdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3dvcmtlcl9hZGRyZXNzKXVwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF93b3JrZXJfcHVia2V5HHVwZGF0ZV92YWxpZGF0b3JfcHJvamVjdF91cmwIdjFfdG9fdjIJdmFsaWRhdG9yDXZhbGlkYXRvcl9jYXAHdmVyc2lvbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhcIBEsDAAMAABEXCwELAgsDCwQLBQsGCwcRKwwJESwMCgsACgoSAAwIDQgPAAsKCwk4AAsIOAECAQEEAAETCwARIwsBCwILAwsECwULBgsHCwgLCQsKCwsLDAsNCw4LDxExAgIBBAABBQsAESMLAREzAgMBBAABBQsAESMLAREwAgQBBAABBQsAESMLAREyAgUBBAABBgsAESMLAQsCETUCBgEEAAEGCwARIwsBCwIROQIHAQQAAQYLABEjCwELAhE0AggBBAABBgsAESMLAQsCETgCCQEEAAEHCwARIwsBCwILAxEuAgoBBAABCAsAESMLAQsCCwMLBBEvAgsBBAABBgsAESMLAQsCETYCDAEEAAEGCwARIwsBCwIRLQINAQQAAQYLABEjCwELAhE7Ag4BBAABBQsAESMLARE3Ag8BBAABBgsAESMLAQsCEUUCEAEEAAEGCwARIwsBCwIRQwIRAQQAAQYLABEjCwELAhFEAhIBBAABBgsAESMLAQsCEU0CEwEEAAEGCwARIwsBCwIRRgIUAQQAAQYLABEjCwELAhE8AhUBBAABBgsAESMLAQsCEUgCFgEEAAEGCwARIwsBCwIRPgIXAQQAAQYLABEjCwELAhFJAhgBBAABBgsAESMLAQsCET8CGQEEAAEGCwARIwsBCwIRSwIaAQQAAQYLABEjCwELAhFBAhsBBAABBwsAESMLAQsCCwMRSgIcAQQAAQcLABEjCwELAgsDEUACHQEEAAEGCwARIwsBCwIRTAIeAQQAAQYLABEjCwELAhFCAh8BBAABBgsAESMLAQsCEUcCIAEEAAEGCwARIwsBCwIRPQIhAAAAEB0LAhEjDAsKCi4RKQcCIQQKBRALCwELCgEHACcLCwsDCwQLAAsBCwULBgsHCwgLCQsKESoCIgAAAAEECwARJC4CIwAAAAEDCwARJAIkAAAAJi8KABABFAYBAAAAAAAAACEEGQoADwAKABABFDgCEU4MAgYCAAAAAAAAAAoADwEVCgAPAAoAEAEUCwI4AwoADwAKABABFDgEDAEKAS4ROgsAEAEUIQQpBS0LAQEHAScLAQIAAAABABUADHN0YWtpbmdfcG9vbMgeoRzrCwYAAAAMAQAWAhY6A1CvAgT/AiYFpQPgAgeFBpAJCJUPYAb1D8gBCr0RQgz/Ee0LDewdHA+IHgQASQEwAg8CEAITAisCLwJKAk0CTgJPAAgMAAAFBwAABwgAAQQHAQAAAgAMAAMBBAEAAQQCDAEAAQYDBwAGCwQABwYCAAgJDAIHAQQBCgoCAAAtAAEAAD8CAwAAQAQFAABUBgcAAFAICQAAGAoDAAA9CwMAADwMAwAAOwwDAABVDQkAAAwOAwAAQQQFAAAVDgMAAEwPBQAANhARAABIEAUAAEcQBQAAJg8SAAAkDxIAAEUTCAAARhMDAAAqFAMAACMVEgAAORYXAAAzDwUAADQPBQAAJxYSAAAeGAUAAB8YBQAAIgMXAAASFgMAARE0IwEAARwxAwEAASA2MwEDASU0EgEAASg0EgEAAS4DHQEAAUQzHQEAAi0AIAADKSgFAQADRTAfAQADUyIFAQADVgMfAQAEHSkqAQAFLC0FAAYXHAMABiEjEQEIBi0AHAAIDi4DAgcECBE3OAIHBAgUNxICBwQILQAbAgcECT4kAwEMCU4kAwEIChkmBQAKQyYnADMaJAUqHikeLgE1CCceKx40KzAaKB4gBSUFIgUjBSEFHwUyGjEaAQcICwEIAAUHCAALBQEICQUDBwgLAAMHCAAIAgcICwEDAgcIAAgCAgMLBQEICQEIAgELBQEICQIHCAALBQEICQIHCAAHCAsBBwgABAcIAAMDAwIHCAADAQYIAAEGCAIBCAcBAQMHCAIDBwgLAgcIAggCAgYIAgYIAgIGCAADAQgBAgYIAQMBCwoCAwgBAgMIAQELCgIJAAkBAQgIAQsDAQkAAQgJAQsFAQkAAQgEAggCAwEGCwUBCQABBgkAAgkABQYDCwUBCAkDCwUBCAkFAwEGCAsBBQIHCwUBCQALBQEJAAILBQEJAAcICwELBgEJAAELBgEICQMDCAELBQEICQIDAwMHCwoCCQAJAQkACQEFAwMIAQMDAgcLBQEJAAMCBwsDAQkACQADCwUBCAkFAwEJAAEGCwMBCQACBggCCwUBCAkCBgsDAQkACQACBgsKAgkACQEJAAEGCQEDAwgBAwNCYWcHQmFsYW5jZQRDb2luAklEBk9wdGlvbhVQb29sVG9rZW5FeGNoYW5nZVJhdGUDU1VJCVN0YWtlZFN1aQtTdGFraW5nUG9vbAVUYWJsZQlUeENvbnRleHQDVUlEFWFjdGl2YXRlX3N0YWtpbmdfcG9vbBBhY3RpdmF0aW9uX2Vwb2NoA2FkZANiYWcHYmFsYW5jZQZib3Jyb3cYY2hlY2tfYmFsYW5jZV9pbnZhcmlhbnRzBGNvaW4IY29udGFpbnMXZGVhY3RpdmF0ZV9zdGFraW5nX3Bvb2wSZGVhY3RpdmF0aW9uX2Vwb2NoBmRlbGV0ZQ9kZXBvc2l0X3Jld2FyZHMFZXBvY2gOZXhjaGFuZ2VfcmF0ZXMMZXh0cmFfZmllbGRzBGZpbGwMZnJvbV9iYWxhbmNlDmdldF9zdWlfYW1vdW50EGdldF90b2tlbl9hbW91bnQQZ2V0X3dpdGhfZGVmYXVsdAJpZBVpbml0aWFsX2V4Y2hhbmdlX3JhdGUZaXNfZXF1YWxfc3Rha2luZ19tZXRhZGF0YQtpc19pbmFjdGl2ZQdpc19ub25lDGlzX3ByZWFjdGl2ZRVpc19wcmVhY3RpdmVfYXRfZXBvY2gHaXNfc29tZQRqb2luD2pvaW5fc3Rha2VkX3N1aQRtYXRoA21pbgNuZXcEbm9uZQZvYmplY3QGb3B0aW9uG3BlbmRpbmdfcG9vbF90b2tlbl93aXRoZHJhdw1wZW5kaW5nX3N0YWtlFHBlbmRpbmdfc3Rha2VfYW1vdW50HXBlbmRpbmdfc3Rha2Vfd2l0aGRyYXdfYW1vdW50GnBlbmRpbmdfdG90YWxfc3VpX3dpdGhkcmF3B3Bvb2xfaWQRcG9vbF90b2tlbl9hbW91bnQScG9vbF90b2tlbl9iYWxhbmNlIXBvb2xfdG9rZW5fZXhjaGFuZ2VfcmF0ZV9hdF9lcG9jaAlwcmluY2lwYWwVcHJvY2Vzc19wZW5kaW5nX3N0YWtlHnByb2Nlc3NfcGVuZGluZ19zdGFrZV93aXRoZHJhdyRwcm9jZXNzX3BlbmRpbmdfc3Rha2VzX2FuZF93aXRoZHJhd3MPcHVibGljX3RyYW5zZmVyEXJlcXVlc3RfYWRkX3N0YWtlFnJlcXVlc3Rfd2l0aGRyYXdfc3Rha2UgcmVxdWVzdF93aXRoZHJhd19zdGFrZV9wcmVhY3RpdmUMcmV3YXJkc19wb29sBnNlbmRlcgRzb21lBXNwbGl0EHNwbGl0X3N0YWtlZF9zdWkWc3Rha2VfYWN0aXZhdGlvbl9lcG9jaBFzdGFrZWRfc3VpX2Ftb3VudAxzdGFraW5nX3Bvb2wDc3VpCnN1aV9hbW91bnQLc3VpX2JhbGFuY2UFdGFibGUIdHJhbnNmZXIKdHhfY29udGV4dBF1bndyYXBfc3Rha2VkX3N1aQl2YWxpZGF0b3INdmFsaWRhdG9yX3NldAV2YWx1ZRd3aXRoZHJhd19mcm9tX3ByaW5jaXBhbBB3aXRoZHJhd19yZXdhcmRzBHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCADKmjsAAAAAAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMICgAAAAAAAAADCAsAAAAAAAAAAwgMAAAAAAAAAAMIDQAAAAAAAAADCA4AAAAAAAAAAwgPAAAAAAAAAAMIEAAAAAAAAAADCBEAAAAAAAAAAwgSAAAAAAAAAAACCyEICA0LAwEDFgsDAQNMA0ILBQEICTgDGgsKAgMIATIDNQMxAxsIBAECAksDNwMCAgQhCAg2CAdHAzoLBQEICQADAAAZEgoAOAAMAQoAES84ATgBBgAAAAAAAAAAOAIGAAAAAAAAAAALAQYAAAAAAAAAAAYAAAAAAAAAAAYAAAAAAAAAAAsAESYSAAIBAwAAIS8OATgDDAYKAC4REiAECQUPCwABCwQBBwsnCgYGAAAAAAAAAAAkBBQFGgsAAQsEAQcSJwsEES8KAC44BAsDCwESAgwFCgAQABQLBhYLAA8AFQsFCwI4BQICAwAAJT0KAAsBEQMMBAwDCgIuETcMBw4EOAMMBQoACgUKAwoCLhE2EQkMBgsFDgY4AxYMCAoAEAEUCggWCgAPARUKABACFAsDFgoADwIVCgAuERIEMAsAEQcFMgsAAQ0ECwY4BgELBAsCOAcLBzgICwgCAwMAACwfDgEQAxQKAC44BCEECQUNCwABBwInCwAOARAEFAwCLgsCERcMAwsBEQQMBA4DDgQ4AxEcCwQCBAAAAAkICwATAgwBAQERLQsBAgUDAAADDwoAEAUUDgE4AxYKAA8FFQsADwYLATgGAQIGAwAALRwLAS4RNgYBAAAAAAAAABYMAwoAEQcKABEICgAPBwoDCgAQBRQKABAIFBIBOAkLAAsDDAIuCwIRHgIHAAAAAx0KABAFFAoAEAEUFwoADwUVCgAQCBQKABACFBcKAA8IFQYAAAAAAAAAAAoADwEVBgAAAAAAAAAACwAPAhUCCAMAABcfCgAQBRQKABAIFBIBDAEKABAFFAoAEAAUFgoADwUVDgEKABAFFBEcCgAPCBUGAAAAAAAAAAALAA8AFQIJAAAALyEKAAsDDAQuCwQRFwwGDgYLAhEbDAgKCAoBJgQUCwgLARcMBQUWBgAAAAAAAAAADAULBQoAEAY4AxEsDAcLAA8GCwc4CgIKAwAAAx0KAA8HCgERHTgJCgAuEREECgUOCwABBw8nCgAuERIgBBQFGAsAAQcRJwsADwkLATgLAgsDAAAyOw4BEAMUCgAuOAQhBAkFDwsAAQsCAQcCJwoALhERBBQFGgsAAQsCAQcQJwoCLhE3DAQLAREEDAMOAzgDDAUKABAFFAoFFwoADwUVCgAQCBQKBRcLAA8IFQsDCwI4BwsEOAgLBQIMAwAAAxAKAC4REiAEBgUKCwABBwwnCwE4DAsADwoVAg0BAAADBAsAEAUUAg4BAAADBAsAEAMUAg8BAAADBAsAEAs4AwIQAQAAAwQLABAEFAIRAQAAAwQLABAJOA0CEgEAAAMECwAQCjgOAhMBAAADDgsCES8KABADFAoAEAQUCwAPCwsBOAoSAgIUAQQABTAKABALOAMMAwoBCgMlBAkFDwsAAQsCAQcEJwsDCgEXBwAmBBYFHAsAAQsCAQcTJwoBBwAmBCEFJwsAAQsCAQcTJwsACwEKAhETCwIuETc4BQIVAQQANRgKAA4BDAIuCwIRFgQIBQwLAAEHDScLARMCDAMBAREtCwAPCwsDOAYBAhYBAAASGQoAEAMUCgEQAxQhBBELABAEFAsBEAQUIQwCBRcLAAELAQEJDAILAgIXAQAALS0KAAoBERoECAsAAREdAgoAEAoKATgPCwERLAwDCgAQCTgQFAwCCgMKAiYEKQUZCgAQBwoDOBEEJAsAEAcLAzgSFAILAwYBAAAAAAAAABcMAwUUCwABER0CGAEAAAMECwAQABQCGQEAAAMECwAQARQCGgAAABIRCgAREQQICwABCAwCBQ8LABAJOBAUCwEkDAILAgIbAAAAEiMKABAMFAYAAAAAAAAAACEECQgMAgUPCgAQDRQGAAAAAAAAAAAhDAILAgQVCwABCwECCgAQDBQ1CwE1GAsAEA0UNRo0AhwAAAASIwoAEAwUBgAAAAAAAAAAIQQJCAwCBQ8KABANFAYAAAAAAAAAACEMAgsCBBULAAELAQIKABANFDULATUYCwAQDBQ1GjQCHQAAAAMEBgAAAAAAAAAABgAAAAAAAAAAEgECHgAAADkWCgALAREXDAMOAwoAEAUUERwMBAsAEAgUDAILBAsCIQQTBRUHCicCAAcACAAJAgECAgADAAQABgAFAAEAAgIDAQABAQBRAFIADHN0b3JhZ2VfZnVuZLUEoRzrCwYAAAALAQAGAgYOAxQsBEAIBUhJB5EBsgEIwwJACoMDDwySA2sN/QMED4EEAgAJAQQBCgACBAABAAQBAAECAQIAAAYAAQAAAwIAAAANAwQAAAwDBAABBQgEAQABCAkHAQABDgoEAQABDwUHAQAHBgQGBQYGBgELAQEIAgEIAAYHCAALAQEIAgsBAQgCCwEBCAIDAwEGCAABAwABCAIBCwEBCQACBwsBAQkACwEBCQACBwsBAQkAAwEGCwEBCQAHQmFsYW5jZQNTVUkLU3RvcmFnZUZ1bmQNYWR2YW5jZV9lcG9jaAdiYWxhbmNlBGpvaW4DbmV3Fm5vbl9yZWZ1bmRhYmxlX2JhbGFuY2UFc3BsaXQMc3RvcmFnZV9mdW5kA3N1aRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyDXRvdGFsX2JhbGFuY2UcdG90YWxfb2JqZWN0X3N0b3JhZ2VfcmViYXRlcwV2YWx1ZQR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgACAg0LAQEIAgcLAQEIAgADAAAFBDgACwASAAIBAwAAAB4KAA8ACwI4AQEKAA8ACwM4AQEKAA8BCwE4AQEKAA8BCwU4AgwGCgAPAAsGOAEBCwAPAQsEOAICAgEAAAUECwAQATgDAgMBAAAFCAoAEAE4AwsAEAA4AxYCAAEAAAALAAx2b3RpbmdfcG93ZXKXDaEc6wsGAAAADAEACAIIDAMUVwRrBAVvhgEH9QGwAgilBGAGhQVGCssFEAzbBf4GDdkMBA/dDAIAFgEVAgkAEgABAgAAAgIAAwAEAAANAAEAAAYCAwAADwQFAAAHBgEAAAMHAQAAEQgBAAAEBAEAABABBQAADAEFAAEHEQEBAAEIExQBAAIFCwUAAgoLBQACCwsFAAMNFQEAAw8OBQADFg4FAAkNCg0BBwoIAgACBgoIAgMCCggBAwEGCggCAQMCBwoIAQgBAwcKCAEDAwIHCggCCggBBAMKCAEDAwEIAgIDAwgDCAEDCggBAwMDAwEIAQEGCAIDAwMDBAMBAwMDBwoJAAkAAwcBAwMDAwMHCAEBBgoJAAEBAgcIAgMMAwMDAwMDAwMDBggCBggCAwlWYWxpZGF0b3IPVm90aW5nUG93ZXJJbmZvEVZvdGluZ1Bvd2VySW5mb1YyE2FkanVzdF92b3RpbmdfcG93ZXIQY2hlY2tfaW52YXJpYW50cxNkaXZpZGVfYW5kX3JvdW5kX3VwFmluaXRfdm90aW5nX3Bvd2VyX2luZm8GaW5zZXJ0CGlzX2VtcHR5BG1hdGgDbWF4A21pbhBxdW9ydW1fdGhyZXNob2xkEHNldF92b3RpbmdfcG93ZXIFc3Rha2ULdG90YWxfc3Rha2USdG90YWxfdm90aW5nX3Bvd2VyE3VwZGF0ZV92b3RpbmdfcG93ZXIJdmFsaWRhdG9yD3ZhbGlkYXRvcl9pbmRleA12YWxpZGF0b3Jfc2V0BnZlY3Rvcgx2b3RpbmdfcG93ZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCBAnAAAAAAAAAwgLGgAAAAAAAAMI6AMAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAAICEwMWAwECAxMDFgMOAwADAAAJHQcABwIHAAoALkEKEQsRDBENDAQKAAoEDAEuCwERAQwDDAINAgsECwMRBAoACwIRBQsALhEGAgEAAAAMOgoAEQIMCAYAAAAAAAAAAAwCCgBBCgwEBgAAAAAAAAAADAdADQAAAAAAAAAADAUKAgoEIwQzBREKAAoCQgoRDwwGCgY1BwA1GAoINRo0CgERDQwJCgIKCQsGEgEMAw0FCwMRAwsHCwkWDAcLAgYBAAAAAAAAABYMAgUMCwABCwUHAAsHFwICAAAADxwGAAAAAAAAAAAMAQoAQQoMAgYAAAAAAAAAAAwDCgEKAiMEGAUMCwMKAAoBQgoRDxYMAwsBBgEAAAAAAAAAFgwBBQcLAAELAwIDAAAAECcGAAAAAAAAAAAMBAoALkENDAUKBAoFIwQZBQsKAAoEDAIuCwJCDRAAFA4BEAAUJAwDBRsJDAMLAwQiCwQGAQAAAAAAAAAWDAQFBgsACwELBDgAAgQAAAASVAYAAAAAAAAAAAwFCgAuQQ0MBgoFCgYjBBAFCwoCBgAAAAAAAAAAJAwDBRIJDAMLAwRKCgAKBUMNDAkKAgoGCgUXEQsMBwoBCgkQARQLBxYRDQwICgILCAoJEAEUFxENDAQKCRABFAoEFgoJDwEVCwkQARQKASUEPQVBCwABBwUnCwILBBcMAgsFBgEAAAAAAAAAFgwFBQYLAAELAgYAAAAAAAAAACEEUQVTBwMnAgUAAAALFg4BOAEgBBEFBQ0BRQ0TAQEMAwwCCgALAkMKCwMRDgUACwABCwFGDQAAAAAAAAAAAgYAAAAWdwYAAAAAAAAAAAwDCgBBCgwEBgAAAAAAAAAADAkKAwoEIwQjBQwKAAoDQgoREAwMCgwGAAAAAAAAAAAkBBYFGgsAAQcGJwsJCwwWDAkLAwYBAAAAAAAAABYMAwUHCwkHACEEKAUsCwABBwMnBgAAAAAAAAAADAEKAQoEIwR0BTMKAQYBAAAAAAAAABYMAgoCCgQjBG8FPAoACgFCCgwKCgAKAkIKDAsKChEPDAcKCxEPDAgLChEQDAULCxEQDAYKBwoIJARdCgUKBiYEWQVdCwABBwQnCwcLCCMEagsFCwYlBGYFagsAAQcEJwsCBgEAAAAAAAAAFgwCBTcLAQYBAAAAAAAAABYMAQUuCwABAgcBAAABAgcAAggBAAABAgcBAgECAQEAFAANc3Rha2Vfc3Vic2lkea4GoRzrCwYAAAAMAQAMAgwWAyIlBEcEBUtKB5UBsAIIxQNABoUEHAqhBBQMtQS0AQ3pBQoP8wUEABIBBgEHAQ4BFQEXAAMEAAEADAACAQQBAAEEAgIABQQCAAAIAAEAAAUCAwAACgQFAAEQBwgAAhENDgEAAhgLBQEAAw8MBQAFCgQKBQsCAQgDAwMNBwgEAQgAAQcIAAELAgEIAwEGCAABAwABBwgEAQgBAwQLAgEIAwMBCAMBBgsCAQkAAgMDAgcLAgEJAAMBCwIBCQADQmFnB0JhbGFuY2UDU1VJDFN0YWtlU3Vic2lkeQlUeENvbnRleHQNYWR2YW5jZV9lcG9jaANiYWcHYmFsYW5jZQZjcmVhdGUbY3VycmVudF9kaXN0cmlidXRpb25fYW1vdW50HGN1cnJlbnRfZXBvY2hfc3Vic2lkeV9hbW91bnQUZGlzdHJpYnV0aW9uX2NvdW50ZXIMZXh0cmFfZmllbGRzB2dlbmVzaXMEbWF0aANtaW4DbmV3BXNwbGl0DXN0YWtlX3N1YnNpZHkbc3Rha2Vfc3Vic2lkeV9kZWNyZWFzZV9yYXRlG3N0YWtlX3N1YnNpZHlfcGVyaW9kX2xlbmd0aANzdWkWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lcgp0eF9jb250ZXh0BXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgQQECcAAAAAAAAAAAAAAAAAAAMIAAAAAAAAAAAAAgYHCwIBCAMLAwkDFAMTDQwIAQADAAAGEwoDBwBLJQQGBQoLBAEHAScLAAYAAAAAAAAAAAsBCwILAwsEEQMSAAIBAwAACTkKABAAFAoAEAE4ABEGDAMKAA8BCwM4AQwCCgAQAhQGAQAAAAAAAAAWCgAPAhUKABACFAoAEAMUGQYAAAAAAAAAACEENQoAEAAUNQoAEAQUNRgHABoMAQoAEAAUCwE0FwsADwAVBTcLAAELAgICAQAABggKABAAFAsAEAE4ABEGAgACAAAAAQADAAQADQAWAA12YWxpZGF0b3JfY2FwgQahHOsLBgAAAAwBAAgCCBQDHCoERgQFSjYHgAHiAgjiA0AGogQiCsQEDQzRBHANwQUED8UFBgASAQoBDgEPAAMMAAAEAgABAAcAAQIEAAMBAgAAEAABAAAUAgEAAAkDBAAACAAFAAEGDQQBCAEHCgsAAgsOBgEMAwwICQAEDAYMAQYIAAEGBQEGCAECBQcIBAEIAgEIAQAEAQgACAIFAQYIBAEFAQcIBAEIAwEIAAEGCQACCQAFAklECVR4Q29udGV4dANVSUQfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcBVWYWxpZGF0b3JPcGVyYXRpb25DYXAcYXV0aG9yaXplcl92YWxpZGF0b3JfYWRkcmVzcwJpZANuZXcTbmV3X2Zyb21fdW52ZXJpZmllZDNuZXdfdW52ZXJpZmllZF92YWxpZGF0b3Jfb3BlcmF0aW9uX2NhcF9hbmRfdHJhbnNmZXIGb2JqZWN0D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lcgh0cmFuc2Zlcgp0eF9jb250ZXh0IHVudmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzCXZhbGlkYXRvcg12YWxpZGF0b3JfY2FwDXZhbGlkYXRvcl9zZXQedmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIGCAMFBQECAQUFAAMAAAYDCwAQAAIBAwAABgMLABABAgIDAAAHIwoBLhEHDAUKBQcAIQQLCAwCBQ8LBQoAIQwCCwIEEgUWCwEBBgAAAAAAAAAAJwsBEQUKABIADAMOAzgADAQLAwsAOAELBAIDAwAABgULABAAFBIBAgABAQAADQARABMADXZhbGlkYXRvcl9zZXS2UKEc6wsGAAAADAEAMwIzcAOjAYYGBKkHhQEFrgjSCQeAErcXCLcpYAaXKsMBCtorjQEM5yz7Ig3iTxAP8k8FAJ8BAWcBpwECHgIfAjkCZQJxAo0BApEBApIBApgBAqUBAqYBAIkBAJsBAJ4BAKMBAKoBABMEAAAOAwAADwMAABADAAARAwABBAcBAAADAAwABAEEAQABBgMHAAcCBgECAAcGBgECAAgHAgAJCQwCBwEEAQoKBAEEAQsLAgAMFQcCAQAAAA0WBwEDAA4FBwAOCAgADw0EABAMDAAQEgIAERQEAABgAAEAAHwCAwAAfgQDAAB7BQMAABwGAwAAfQQDAAB6BwMAAIABCAMAAH8JAwAAGwoDAACaAQsDAAA0DAMAAC8NDgAAlQENDgAAogEPDgAAoAEPDgAAoQEPEAAAiwENEQAAYw0OAABRDxIAAFQGEgAAUxMSAAArEw4AAFUGEgAAKhQOAABEFRYAADwXGAAAPRkYAABHGhsAAEgcFgAAQR0WAABLHhYAAEkfFgAASh8WAABMFyAAAEIhIAAAQw8gAABGDyAAAKkBIiMAAHIkAwAAdSUDAAAjJgMAAHQnAwAAhQEoAwAAcykDAAAiKg4AABorAwAAJiwtAAAnLi8AACgwMQAAJTIxAAAzMwMAADY0AwAAkAEaDgAAGA0qAABaDxIAAFc1EgABMW9RAQABO1BRAQABWU8SAQABZANvAQABhAFRbwEAAilSEgEAAlZ9EgEAAnlhUQEAA2A4QgAEMpQBAwEABFyVAQ4BAASGAZMBlAEBAASkAVQOAQAFNVEDAQMGTW4QAQgHYGdoAQIHYWVmAQIHcGllAQIJGTwDAgcECSBEVwIHBAkhSVkCBwQJKUQSAgcECWA4OQIHBAl5SUoCBwQKIG1uAQQKIXJzAQQKNzg9AQQKVmoSAQQKXmoOAQQKb4cBUQEECnZNAwEECzhIDgALgQFIOwAMKV0SAgEADDcDQQIBAAxAXVcCAQAMRV5ZAgEADE9gAwIBAAxWggESAgEADF2CAYMBAgEADG6OAV8CAQAMeV5fAgEADIMBggEOAgEADSmEARIBAw1QjwGDAQEDDVaGARIBAw15hQEDAQMOalYQAA8XSwMADxoWAwAPJCAOAA8tSwMADy6WAQMADzQWAwAPPiAOAA9SbBIAD1ggEgAPZiB7AA9tmAGZAQAPc4oBAwAPelUDAA9/SwMAD4ABWAMAD4gBIA4AD4oBIBAAD44BIDsAD5YBIA4AD6oBIA4AEGJ5IwAQmQF5dQAQqAF0dQARLEVGABEwRjoAEV9aFgASdwMOABKCASsDABKXAQMOAE83SzdTOk8+Tz9bQE4/Sz9QP1A3Sz5XOjsOOg4+DkVTTjdMN04+TT5aQGJAXUBeQEA6SQ5IDkoOVTpROk0/PQ48DjkOUjpHej8ORn9agQFigQFggQFdgQFkO2c7ZjtUOlY6RogBW2JeYl+BAWGBAWU7Y2JaYlxiRFNDU0JTXIEBPjtGmgECCggTBwgOAQgAAwcIAAgTBwgOAAIHCAAHCA4DBwgAAwcIDgIGCAAGCBMEBwgABQsHAQgLBwgOAwcIAAgSBwgOAwcIAAMGCA4JBwgABwsHAQgLBwsHAQgLBwsPAgULEAEFAwMDAwcIDgYHCAADAwMHCw8CBQsQAQUHCA4BBwgAAQYIAAEDAgYIAAUBCAgBBgsMAggIBQEBAgYKCBMGCBMCBgsNAQgTBggTAgcIAAUBBwgTAgYKCBMFAQsFAQMCBgsNAQgTBQIGCggTBgoFAQoDAgcKCBMFAwcIAAUBAwcIAAYIFQECBwgABggOAQYIEwMHCAAFAgMHCAAGCBQCAQgVAwcIAAcLDwIFCxABBQcIDgUHCAAIEwcLDwIFCxABBQEHCA4CBwsPAgULEAEFBQIHCAADAQcKAwIHCggTBwgOAQYKCBMBBwoIEwQKAwMGCgMGCgMEAwsPAgMDAwsPAgMDAgYIAAsPAgULEAEFAQoFBAYKCBMDAwMCCgMKAwkGCggTAwMKAwoDAwsPAgMDAwsPAgMDBgcKCBMGCgMGCgMHCwcBCAsHCwcBCAsHCA4GAwYKCBMGCgMGCgMGCw8CBQsQAQUGCgUCBggACAgGAwMLDAIICAUDBggTCAACCAgFAQcIDgELDAIJAAkBAQgTAQUDBwsMAgkACQEJAAkBAQsNAQkAAggICBYCBQgWAgUDAQsPAgkACQEBCAYEBggTBggTAQUCBgsMAgkACQEJAAIIEwcIDgEIFgMICAgTBQEGCA4CBwsMAgkACQEJAAEJAQIHCBMDBQYIEwYIEwEIEwUCBwsNAQkACQADBQMLBQEDAQYLBQEJAAEHCwUBCQABCQACBgoJAAYJAAEICwEGCwcBCQAEBwgTCwcBCAsFBwgOAQYIEgEGCQEDBwgTCBIHCA4BBwkBAQcIFg4LDwIFCxABBQYKBQoDCgMLDwIDAwsPAgMDAwoFAwMDAwoDCgMIAwMHAwMIEwgTBQYIEwIGCw8CCQAJAQYJAAIHCw8CCQAJAQYJAAIJAAkBAwcLDwIJAAkBCQAJAQIHCgkAAwIDAwoKCwkBAwMDCwoBAwMDAwMGCBMGCggTAQsJAQMCAwkAAQsJAQkAAQoLCQEJAAELCgEJAAEHCwoBCQABBgsNAQkAAwMDAwIGCBMGCBMCBgsNAQkAAwEGCQABCwUBCQAFBQMLBQEDAwoDBAMDCwUBAwsFAQMCBwsNAQkAAwEHCQABBggVAQYFAgMLBQEDBgEBAwMLBQEDCwUBAwUFBggTCAgFBggTAQYIFAEIFAEGCAgCAwgTAQYKCQADAwUICAEIBAcGBQYFAwMGBQoFBwsQAQUCBQsQAQUBBgsPAgkACQEBCgkAAgYLEAEJAAYJAAIHCxABCQAGCQABBgsQAQkAAQcLDQEJAAEIAwYDAwMDAwMCBwgTBwgOBAMDAwYIEwcLDwIDAwsPAgMDBAQDAwMFCgUGCggTCxABBQoFBQEHCw8CCQAJAQELEAEJAAYDAwQKAwoDAxEDAwMKAwMKAwMEAwMDAwMDAwMECAMDCwcBCAsDBwgTBQQLBwEICwIHCwcBCQADAQsHAQkAAgcLBwEJAAsHAQkAAgcIEwsHAQgLCAoFAwMDAwoFBggTBQIGCBMDAQgRAQgCA0JhZwdCYWxhbmNlBUVudHJ5AklEBk9wdGlvbhVQb29sVG9rZW5FeGNoYW5nZVJhdGUNUHJpb3JpdHlRdWV1ZQNTVUkJU3Rha2VkU3VpBVRhYmxlCFRhYmxlVmVjCVR4Q29udGV4dB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwCVZhbGlkYXRvchdWYWxpZGF0b3JFcG9jaEluZm9FdmVudBlWYWxpZGF0b3JFcG9jaEluZm9FdmVudFYyElZhbGlkYXRvckpvaW5FdmVudBNWYWxpZGF0b3JMZWF2ZUV2ZW50FVZhbGlkYXRvck9wZXJhdGlvbkNhcAxWYWxpZGF0b3JTZXQQVmFsaWRhdG9yV3JhcHBlcgZWZWNNYXAGVmVjU2V0CGFjdGl2YXRlEWFjdGl2ZV92YWxpZGF0b3JzA2FkZBphZGp1c3Rfc3Rha2VfYW5kX2dhc19wcmljZQ1hZHZhbmNlX2Vwb2NoJmFzc2VydF9ub19wZW5kaW5nX29yX2FjdGl2ZV9kdXBsaWNhdGVzEmF0X3Jpc2tfdmFsaWRhdG9ycwNiYWcHYmFsYW5jZQZib3Jyb3cKYm9ycm93X211dBZjYWxjdWxhdGVfdG90YWxfc3Rha2VzJmNsZWFuX3JlcG9ydF9yZWNvcmRzX2xlYXZpbmdfdmFsaWRhdG9yD2NvbW1pc3Npb25fcmF0ZSRjb21wdXRlX2FkanVzdGVkX3Jld2FyZF9kaXN0cmlidXRpb24aY29tcHV0ZV9yZXdhcmRfYWRqdXN0bWVudHMaY29tcHV0ZV9zbGFzaGVkX3ZhbGlkYXRvcnMmY29tcHV0ZV91bmFkanVzdGVkX3Jld2FyZF9kaXN0cmlidXRpb24IY29udGFpbnMZY291bnRfZHVwbGljYXRlc190YWJsZXZlYxRjb3VudF9kdXBsaWNhdGVzX3ZlYwljcmVhdGVfdjEKZGVhY3RpdmF0ZRVkZXBvc2l0X3N0YWtlX3Jld2FyZHMaZGVyaXZlX3JlZmVyZW5jZV9nYXNfcHJpY2UHZGVzdHJveQxkZXN0cm95X3NvbWUMZGVzdHJveV96ZXJvEWRpc3RyaWJ1dGVfcmV3YXJkGmVmZmVjdHVhdGVfc3RhZ2VkX21ldGFkYXRhBGVtaXQbZW1pdF92YWxpZGF0b3JfZXBvY2hfZXZlbnRzBWVtcHR5BWVwb2NoBWV2ZW50DGV4dHJhX2ZpZWxkcwdleHRyYWN0DmZpbmRfdmFsaWRhdG9yHWZpbmRfdmFsaWRhdG9yX2Zyb21fdGFibGVfdmVjCWdhc19wcmljZQdnZW5lc2lzA2dldDBnZXRfYWN0aXZlX29yX3BlbmRpbmdfb3JfY2FuZGlkYXRlX3ZhbGlkYXRvcl9tdXQwZ2V0X2FjdGl2ZV9vcl9wZW5kaW5nX29yX2NhbmRpZGF0ZV92YWxpZGF0b3JfcmVmGGdldF9hY3RpdmVfdmFsaWRhdG9yX3JlZiVnZXRfY2FuZGlkYXRlX29yX2FjdGl2ZV92YWxpZGF0b3JfbXV0B2dldF9tdXQZZ2V0X3BlbmRpbmdfdmFsaWRhdG9yX3JlZhVnZXRfdmFsaWRhdG9yX2luZGljZXMRZ2V0X3ZhbGlkYXRvcl9tdXQaZ2V0X3ZhbGlkYXRvcl9tdXRfd2l0aF9jdHgvZ2V0X3ZhbGlkYXRvcl9tdXRfd2l0aF9jdHhfaW5jbHVkaW5nX2NhbmRpZGF0ZXMjZ2V0X3ZhbGlkYXRvcl9tdXRfd2l0aF92ZXJpZmllZF9jYXARZ2V0X3ZhbGlkYXRvcl9yZWYCaWQTaW5hY3RpdmVfdmFsaWRhdG9ycwZpbnNlcnQJaW50b19rZXlzImlzX2FjdGl2ZV92YWxpZGF0b3JfYnlfc3VpX2FkZHJlc3MMaXNfZHVwbGljYXRlFmlzX2R1cGxpY2F0ZV92YWxpZGF0b3IiaXNfZHVwbGljYXRlX3dpdGhfYWN0aXZlX3ZhbGlkYXRvciNpc19kdXBsaWNhdGVfd2l0aF9wZW5kaW5nX3ZhbGlkYXRvcghpc19lbXB0eRVpc19pbmFjdGl2ZV92YWxpZGF0b3IMaXNfcHJlYWN0aXZlB2lzX3NvbWUWaXNfdmFsaWRhdG9yX2NhbmRpZGF0ZQxpc192b2x1bnRhcnkEam9pbgRrZXlzBmxlbmd0aBxsb2FkX3ZhbGlkYXRvcl9tYXliZV91cGdyYWRlA25ldwluZXdfZW50cnkTbmV3X2Zyb21fdW52ZXJpZmllZBpuZXh0X2Vwb2NoX3ZhbGlkYXRvcl9jb3VudARub25lBm9iamVjdBBvcGVyYXRpb25fY2FwX2lkBm9wdGlvbhlwZW5kaW5nX2FjdGl2ZV92YWxpZGF0b3JzEHBlbmRpbmdfcmVtb3ZhbHMHcG9vbF9pZBNwb29sX3N0YWtpbmdfcmV3YXJkGHBvb2xfdG9rZW5fZXhjaGFuZ2VfcmF0ZSFwb29sX3Rva2VuX2V4Y2hhbmdlX3JhdGVfYXRfZXBvY2gDcG9wCHBvcF9iYWNrB3BvcF9tYXgOcHJpb3JpdHlfcXVldWUYcHJvY2Vzc19wZW5kaW5nX3JlbW92YWxzJHByb2Nlc3NfcGVuZGluZ19zdGFrZXNfYW5kX3dpdGhkcmF3cxpwcm9jZXNzX3BlbmRpbmdfdmFsaWRhdG9ycxtwcm9jZXNzX3ZhbGlkYXRvcl9kZXBhcnR1cmUJcHVzaF9iYWNrEHF1b3J1bV90aHJlc2hvbGQacmVmZXJlbmNlX2dhc19zdXJ2ZXlfcXVvdGUGcmVtb3ZlEXJlcXVlc3RfYWRkX3N0YWtlFXJlcXVlc3RfYWRkX3ZhbGlkYXRvch9yZXF1ZXN0X2FkZF92YWxpZGF0b3JfY2FuZGlkYXRlGHJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvciJyZXF1ZXN0X3JlbW92ZV92YWxpZGF0b3JfY2FuZGlkYXRlG3JlcXVlc3Rfc2V0X2NvbW1pc3Npb25fcmF0ZRZyZXF1ZXN0X3dpdGhkcmF3X3N0YWtlBnNlbmRlchBzZXRfdm90aW5nX3Bvd2VyBHNpemUEc29tZRFzb3J0X3JlbW92YWxfbGlzdAVzcGxpdAVzdGFrZQxzdGFrZV9hbW91bnQMc3Rha2luZ19wb29sD3N0YWtpbmdfcG9vbF9pZBVzdGFraW5nX3Bvb2xfbWFwcGluZ3Mbc3RvcmFnZV9mdW5kX3N0YWtpbmdfcmV3YXJkA3N1aQtzdWlfYWRkcmVzcxZzdWlfc3lzdGVtX3N0YXRlX2lubmVyHXN1bV92b3RpbmdfcG93ZXJfYnlfYWRkcmVzc2VzBXRhYmxlCXRhYmxlX3ZlYxp0YWxseWluZ19ydWxlX2dsb2JhbF9zY29yZRd0YWxseWluZ19ydWxlX3JlcG9ydGVycwt0b3RhbF9zdGFrZRJ0b3RhbF9zdGFrZV9hbW91bnQSdG90YWxfdm90aW5nX3Bvd2VyCnR4X2NvbnRleHQgdW52ZXJpZmllZF9vcGVyYXRpb25fY2FwX2FkZHJlc3MndXBkYXRlX2FuZF9wcm9jZXNzX2xvd19zdGFrZV9kZXBhcnR1cmVzCXZhbGlkYXRvchF2YWxpZGF0b3JfYWRkcmVzcxR2YWxpZGF0b3JfY2FuZGlkYXRlcw12YWxpZGF0b3JfY2FwDXZhbGlkYXRvcl9zZXQWdmFsaWRhdG9yX3N0YWtlX2Ftb3VudBl2YWxpZGF0b3Jfc3Rha2luZ19wb29sX2lkHHZhbGlkYXRvcl90b3RhbF9zdGFrZV9hbW91bnQRdmFsaWRhdG9yX3dyYXBwZXIFdmFsdWUHdmVjX21hcAd2ZWNfc2V0BnZlY3Rvch52ZXJpZmllZF9vcGVyYXRpb25fY2FwX2FkZHJlc3MKdmVyaWZ5X2NhcAx2b3RpbmdfcG93ZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAQECAQICAQMEEBAnAAAAAAAAAAAAAAAAAAADCADKmjsAAAAAAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMICgAAAAAAAAADCAsAAAAAAAAAAwgMAAAAAAAAAAMIDQAAAAAAAAADCGUAAAAAAAAACgMBAAoFAQAAAgmVAQMYCggTaAsNAQgTaQoDiwELDAIICAVOCwwCCAgIFp0BCwwCBQgWHQsPAgUDOggGAQIKOAOcAQV4A4cBAyQDawOMAQNsCBGUAQoFkwEDAgILOAOcAQV4A4cBA6oBAyQDawOMAQNsCBGUAQoFkwEDAwIDOAOcAQWKAQgIBAIEOAOcAQWKAQgIWwEAAwAANjMOABEtDAUKATgADAQOAEE6DAMGAAAAAAAAAAAMAgoCCgMjBB8FEA4ACgJCOgwGDQQKBhF5CwYRejgBCwIGAQAAAAAAAAAWDAIFCwsFCwAKATgCQA4AAAAAAAAAAAsECgE4AwoBOAQ4BQsBEUESAAwHDQcPABGEAQsHAgEDAABDRQoADgEMAy4LAxEUIAQRCgAOAQwELgsEERcgDAUFEwkMBQsFBBYFHAsAAQsCAQcHJw4BEXoMBgoAEAEKBjgGIAQmBSwLAAELAgEHCycOARFxBDAFNgsAAQsCAQcMJwoADwIOARF5CwY4AQsADwEOARF6CwELAhGAATgHAgIDAABHNQoBLhFZDAQKABABCgQ4BgQKBRALAAELAQEHDScKAA8BCwQ4CBGBAQwDDgMRcQQaBSALAAELAQEHDCcOAxF5DAIKAA8CCgI4CQENAwoBLhFYEWwLAA8DCwILAwsBEYABOAoCAwMAAExFCwIuEVkMBwoAEAEKBzgGBAoFDgsAAQcNJwoADwELBzgIEYEBDAYKAA4GDAMuCwMRFCAEJQoADgYMBC4LBBEXIAwFBScJDAULBQQqBS4LAAEHBycOBhFxBDIFNgsAAQcMJw4GEXsLASYEPAVACwABBwonCwAPBAsGOAsCBAMAAAMQCgAQAAoBERYLABAECwERGBYGAQAAAAAAAAAhBA0FDwcHJwIFAwAATiQLAS4RWQwCCgAQAAsCERoMBA4EOAwEDQURCwABBwknDQQ4DQwDCgAQBQ4DOA4gBBsFHwsAAQcQJwsADwULA0QOAgYDAAADFg4COA8HBCYEBgUMCwABCwMBBw8nCwALAREZCwIKAy4RWQsDEXUCBwMAADcrDgERaAwDCgAQAgoDOBAEFgoAEAIOARFoOBEUDAQLAAsEERkLAQsCEXcFKgoAEAMKAzgSBBwFIgsAAQsCAQcIJwsADwMLAzgTEYIBCwELAhF3AggDAAA7CgsCEVkMAwsADwALAxEdCwERdgIJAwAAW24KCC4RWAYBAAAAAAAAABYMDxGFAQwUCgAQAAoUCgEuOA8KAi44DxExDBYMFQoACgMUDAkuCwkRMAwQCgAQAA4QETUMEQoAEAAOEBEcCwQOFQ4WES8MDgwTDA0MEgoAEAALFAsRCxULFgsSCw0LEwsOETIMDAwLCgAPAA4LDgwLAQsCCggRMwoADwARLgoADwAKCBEsCg8KABAADgsODAoDDhAMCi4LChE0CgALDxEqCgAKAwoIEScKAAsFCwYLBwsDCwgRCgoAEAARLQoADwYVCgAPABGEAQsAEQsCCgAAAFxqCgAQAEE6DAcKBwYAAAAAAAAAACQEYwUJCwcGAQAAAAAAAAAXDAcKABAACgdCOgwNCg0RegwMCw0RewwJCgkKASYEKAoAEAcODDgUBCcKAA8HDgw4FQEBBWILCQoCJgRXCgAQBw4MOBQEQAoADwcODDgWDAgKCBQGAQAAAAAAAAAWCggVCwgUDAYFRwoADwcLDAYBAAAAAAAAADgXBgEAAAAAAAAADAYLBgoDJARWCgAPAAoHOBgMCgoACwoKBAkKBREoBWIKAA8ACgc4GAwLCgALCwoECQoFESgFBAsEAQsAAQsFAQILAAAAYhgKABAAQToMAgYAAAAAAAAAAAwBCgEKAiMEFQULCgAPAAoBQzoRbgsBBgEAAAAAAAAAFgwBBQYLAAECDAEAAGM8CwAQAAwKCgpBOgwDQGQAAAAAAAAAAAwBBgAAAAAAAAAADAIKAgoDIwQfBQ8KCgoCQjoMCQ0BCgkRbwsJEXw4GURkCwIGAQAAAAAAAAAWDAIFCgsKAQsBOBoMBAYAAAAAAAAAAAwHEYUBEYMBFwwIBgAAAAAAAAAADAUKBwoIIwQ6BTENBDgbDAYMBQsHCwYWDAcFLAsFAg0BAAADBAsAEAYUAg4BAAADBgsAEAALAREiEXsCDwEAAAMGCwAQAAsBESIReAIQAQAAAwYLABAACwERIhF5AhEBAAADAwsAEAICEgMAAAMMCgAQAEE6CgAQBUEOFwsAEAQ4HBYCEwMAABgICwAQAAsBERoMAg4COAwCFAAAAAMFCwAQAAsBERUCFQMAAAMGCwALAREWBgAAAAAAAAAAJAIWAAAAayEKAEE6DAMGAAAAAAAAAAAMAgYAAAAAAAAAAAwECgIKAyMEGwUMCgAKAkI6CgERcAQWCwQGAQAAAAAAAAAWDAQLAgYBAAAAAAAAABYMAgUHCwABCwEBCwQCFwAAAAMHCwAQBAsBERgGAAAAAAAAAAAkAhgAAABrIQoAOBwMAwYAAAAAAAAAAAwCBgAAAAAAAAAADAQKAgoDIwQbBQwKAAoCOB0KARFwBBYLBAYBAAAAAAAAABYMBAsCBgEAAAAAAAAAFgwCBQcLAAELAQELBAIZAAAAAxAKABABCgE4BgQLCwAPAQsBOB4RggECCwAPAAsBER0CGgAAAGIfCgBBOgwDBgAAAAAAAAAADAIKAgoDIwQbBQoKAAoCQjoRegoBIQQWCwABCwI4HwILAgYBAAAAAAAAABYMAgUFCwABOCACGwAAAGIfCgA4HAwDBgAAAAAAAAAADAIKAgoDIwQbBQoKAAoCOB0RegoBIQQWCwABCwI4HwILAgYBAAAAAAAAABYMAgUFCwABOCACHAAAAHAuCgFBOwwFBgAAAAAAAAAADAMHFAwGCgMKBSMEKAUMCgEKA0I7FAwCCgALAhEaDAQOBDgMBBkFHwsAAQsBAQcJJw0GCwQ4IUQOCwMGAQAAAAAAAAAWDAMFBwsAAQsBAQsGAh0DAABOFgoACwEMAi4LAhEaDAQOBDgMBAsFDwsAAQcJJw0EOA0MAwsACwNDOgIeAAAAcS0KABAACgERGgwFDgU4DAQQDQU4DQwDCwAPAAsDQzoCCgAQBAoBERsMBg4GOAwEIA0GOA0MBAsADwQLBDgiAgsCBCMFJwsAAQcOJwsADwELATgeEYIBAh8DAAADBwsACwERfxQLAhEeAiADAAA7CAsBEVkMAgsACwIJER4CIQMAADsICwERWQwCCwALAggRHgIiAAAAdhMKAAsBERoMAw4DOAwECAUMCwABBwknDQM4DQwCCwALAkI6AiMDAAB3OQoAEAAKAREaDAcOBzgMBAsIDAMFDwoCBwAhDAMLAwQZDQc4DQwFCwAQAAsFQjoCCgAQBAoBERsMCA4IOAwEJAgMBAUoCwIHASEMBAsEBDINCDgNDAYLABAECwY4HQILAA8BCwE4HhGCAS4CJAEAAHYVCgAQAAsBERoMAw4DOAwECQUNCwABBwknDQM4DQwCCwAQAAsCQjoCJQEAAHYVCgAQBAsBERsMAw4DOAwECQUNCwABBxEnDQM4DQwCCwAQBAsCOB0CJgMAAHgnCgERfhQMBgoCBwAhBBALAAsGDAMuCwMRJAwEBRULAAsGCwIRIwwECwQMBwoBOCMMBQsHEXIOBSEEIAUkCwEBBxMnCwERfQInAAAAfCAKAA8FESsKABAFOCQgBBkFCQoADwVFDgwDCgAPAAsDOBgMBAoACwQKAQgKAhEoBQMLAQELAAELAgECKAAAAH46CgQuEVgGAQAAAAAAAAAWDAUOARF6DAYOARF5DAcKAA8CCgc4CQEKABAHDgY4FAQcCgAPBw4GOBUBAQoAEAYUDgERexcKAA8GFQsCCgYRKQoFCwYOARF5CwMSBDglDQELBRFsCwAPAwsHCwELBBGAATgKAikAAACAAUUKAA4BDAIuCwI4JgQMCgAOATgnAQEKAC44KAwHDgdBOwwFBgAAAAAAAAAADAQKBAoFIwRCBRoOBwoEQjsMBgoACgY4KQwICggOAQwDLgsDOCoEOQoIDgE4KwsILjgsBDYKAAsGOCcBAQU4CwYBBT0LCAELBgELBAYBAAAAAAAAABYMBAUVCwABAioAAAA6HAoAEAQ4LSAEGQUGCgAPBDguDAINAgoBEWkKAQ4CEXoOAhF5EgM4LwoADwALAkQ6BQALAAECKwAAAIkBOQoALkEODAYGAQAAAAAAAAAMBAoECgYjBDYFCwoACgQMAS4LAUIOFAwDCgQMBQoFBgAAAAAAAAAAJAQxBRoLBQYBAAAAAAAAABcMBQoACgUMAi4LAkIOFAoDJAQpBSoFMQoACgUKBQYBAAAAAAAAABZHDgUVCwQGAQAAAAAAAAAWDAQFBgsAAQIsAAAAYhoKAC5BOgwDBgAAAAAAAAAADAIKAgoDIwQVBQsKAAoCQzoKARF0CwIGAQAAAAAAAAAWDAIFBgsAAQsBAQItAAAAiwEeBgAAAAAAAAAADAMKAEE6DAIGAAAAAAAAAAAMAQoBCgIjBBoFDAoACgFCOgwECwMLBBF7FgwDCwEGAQAAAAAAAAAWDAEFBwsAAQsDAi4AAABiFwoALkE6DAIGAAAAAAAAAAAMAQoBCgIjBBQFCwoACgFDOhFqCwEGAQAAAAAAAAAWDAEFBgsAAQIvAAAAjAFFBgAAAAAAAAAADAg4MAwEBgAAAAAAAAAADAk4MAwFDQAuOCQgBDwFDg0ARQ4MCgoCCgpCDhQ1CgE1GAcDGgwGDQQKCgoGNDgxCwgLBjQWDAgKAwoKQg4UNQoBNRgHAxoMBw0FCwoKBzQ4MQsJCwc0FgwJBQgLAwELAgELCAsECwkLBQIwAAAAjQEoBxUMBQ4BODIgBCQFBw0BODMMBAwGCgAKBhETBBAFFAsAAQcFJwoAEAAMAwsEODQMAgsDDgIRNRGDASYEIw0FCwZEOwUCCwABCwUCMQAAAJABL0AOAAAAAAAAAAAMB0AOAAAAAAAAAAAMCAoAQToMBQsDCgUaDAkGAAAAAAAAAAAMBAoECgUjBCoFEgoACgRCOhF8NQoCNRgKATUaDAYNBwsGNEQODQgKCUQOCwQGAQAAAAAAAAAWDAQFDQsAAQsHCwgCMgAAAJEBbAsBCwIXDBZADgAAAAAAAAAADAxADgAAAAAAAAAADA4KAEE6DBQKFA4GODUXDBUGAAAAAAAAAAAMEwoTChQjBGcFFwoAChNCOhF8NQwZDgMKE0IOFAwXDgYOEzg2BDAOBg4TODcUDA8LFwsPFwwJBT0KBTULGRgKFjUaDBALFwsQNBYMCQsJDAsNDAsLRA4OBAoTQg4UDBgOCA4TODYEVQ4IDhM4NxQMEQsYCxEXDAoFXQoHChUaDBILGAsSFgwKCwoMDQ0OCw1EDgsTBgEAAAAAAAAAFgwTBRILAAELDAsOAjMAAACSAWkKAC5BOgwHCgcGAAAAAAAAAAAkBAkFFwsAAQsEAQsDAQsFAQsCAQsBAQcSJwYAAAAAAAAAAAwGCgYKByMEXAUeCgAKBkM6DAoKAQoGQg4UDAkKAwoJODgMCAsJNQoKLhFrNRgHAxoMDA0ICww0ODgMDQ0NCgQKAgoGQg4UODg4OQEODTgPBgAAAAAAAAAAJARSCgouEXoMCwoKCw0LCwoFEXUFVAsNODoLCgsIEW0LBgYBAAAAAAAAABYMBgUZCwABCwQBCwMBCwUBCwIBCwEBAjQAAACXAVQKAUE6DAkGAAAAAAAAAAAMCAoICgkjBEkFCgoBCghCOgwMCgwRegwNCgQODTgmBBwKBA4NODsUODQMBgUeBxUMBgsGDAsKBQ4NODwEJwYAAAAAAAAAAAwHBSkGAQAAAAAAAAAMBwsHDAoKAAsNCgwRbwoMEXsKDBF8CgwRawoCCghCDhQKAwoIQg4UCwwKABFzCwsLChICOD0LCAYBAAAAAAAAABYMCAUFCwEBCwMBCwUBCwQBCwIBAjUBAACLASMGAAAAAAAAAAAMBAYAAAAAAAAAAAwCCgFBOwwDCgIKAyMEHQUMCgAKAQoCQjsUESIMBQsECwURfBYMBAsCBgEAAAAAAAAAFgwCBQcLAAELAQELBAI2AQAAAwMLABAAAjcBAAADBQsAEAELATgGAjgBAAADBQsAEAMLATgSAgABAAYABAAFAAIAAwAAAAcAPwCPAQARdmFsaWRhdG9yX3dyYXBwZXLDBKEc6wsGAAAADAEACAIIEAMYMARIBgVONAeCAdMBCNUCQAaVAwoKnwMGDKUDZA2JBAIPiwQCAA4BCgEQAAwAAgQAAQACAAIDDAADAQQAAAUAAQAACAIDAAAGAQQAAAsCBQAADwYHAAIECAkBBAIGCQwBBAIJCgsBBAIPDQcABQQHBAYEAggDBwgBAQgAAQcIAAEHCAMBCAMAAQYIAAEDAwMJAAcIAQEIAgEHCAIBBwkAAQkAAQYIAglUeENvbnRleHQJVmFsaWRhdG9yEFZhbGlkYXRvcldyYXBwZXIJVmVyc2lvbmVkBmNyZWF0ZQljcmVhdGVfdjEHZGVzdHJveQVpbm5lchxsb2FkX3ZhbGlkYXRvcl9tYXliZV91cGdyYWRlDmxvYWRfdmFsdWVfbXV0CnR4X2NvbnRleHQRdXBncmFkZV90b19sYXRlc3QJdmFsaWRhdG9yDXZhbGlkYXRvcl9zZXQRdmFsaWRhdG9yX3dyYXBwZXIHdmVyc2lvbgl2ZXJzaW9uZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAACAQcIAgADAAAFBgYBAAAAAAAAAAsACwE4ABIAAgEDAAAFBgoAEQMLAA8AOAECAgMAAAUGDQARAwsAEwA4AgIDAAAABQoLAC4RBAYBAAAAAAAAACEEBwUJBwAnAgQAAAAFBAsAEAARCAIAAAANABZzdWlfc3lzdGVtX3N0YXRlX2lubmVylUGhHOsLBgAAAAwBAC0CLWgDlQHUBQTpBjIFmwf7BgeWDrwdCNIrYAayLHUKpy29AQzkLsIRDaZALg/UQAQAcAFEAhkCGgIbAicCQwJGAm4CcgJ4AnkCrgECrwEAZABnAGoAoQEAogEApgEADAQAAA0EAAAJBAAACgQAAAsDAAEEBwEAAAIADAADAQQBAAEEAgwBAAEGAwcACAUCAAkODAIHAQQBCw8CAAwUBwIBAAAADRUHAQMADgYEAA8HCAAQCAQAEREEABIQDAASEgIAExMEAAAdAAEAAB4CAwAAoAEBBAAAUAUGAABSBwYAAE8HBgAAUQcGAABUCAYAAGAIBgAAUwkGAABfCQYAAE0KBgAATgsGAABVDAYAAEsNBgAAeg0GAABMDgYAAHsOBgAAVgcGAACXAQ8GAACVAQ8GAACWAQ8GAACfAQ8GAACYAQ8GAACBAQ8GAACaAQ8GAACDAQ8GAACbAQ8GAACEAQ8GAACdAQ8GAACGAQ8GAACcARAGAACFARAGAACeAQ8GAACHAQ8GAACZAQ8GAACCAQ8GAAAXERIAACQTFAAARxMUAABxExQAACwGFAAAJhMUAACnARUUAACoARUWAACpARMXAAAvFRgAADETFAAAMBMUAAApGRIAASBeQAEAATldOwEAAkAjJAADISIGAQADOlEUAQADYlUiAQADrQFTFAEAA7IBUCIBAAOzAQYiAQAEKl82AQAENjYiAQAFIkAGAQMHO1wGAQAKSGAGAQwLJCcUAAtcJygADBw/OwIBAAwjBiACAQAMLT9ZAgEADC5DRAIBAAw1QgYCAQAMSkNJAgEADRxFOwEDDSMGQQEDDTVGBgEDDThIOwEDDUpHBgEDDWFAQQEDDhdUEgAPYzgUABAXVxIAEEASHgAQc1IUABB1UhQAEUApJgARQUoGABFUMgYAEV01BgARXjIGABF8SwYAEX1LBgARfksGABF/SwYAEYABTgYAEYgBSwYAEYkBSwYAEYoBSwYAEYsBSwYAEYwBSwYAEY0BSwYAEY4BSwYAEY8BSwYAEZABSwYAEZEBTgYAEZIBSwYAEZMBSwYAEZQBSwYAErABPT4AExYdLQATF1YGABMYTQYAEx8dFAATMjQxABMzNDEAEzQwMQATNzo7ABNAGxwAE0IdFAATTTcGABNPLAYAE1AqBgATUSsGABNSKwYAE1MzBgATVTkGABNoHRcAE3YdFAATqAE6FgATqgE6FAATsQEvLgBDHzohPCFCH00oRh9FH0goSihMKEsoRx85ITYhOCE3IT1YRB9JKD4hMxQyFDshP1s1IQcKCBILBwEICgMDCAAIDwcIDAEIAggDAwMDAwMDBwgMAQgAAQgDEAcIAwoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgMAAIHCAMHCAwDBwgDBggTAwMHCAMDBwgMBAcIAwsIAQgKBQcIDAUHCAMKCwgBCAoLBQEDBQcIDAMHCAMIEAcIDAMHCAMGCBMFAwgUBQcLDQIFCw4BBQMHCAMKAgYIDAQHCAMKAgoCBggMCwcIAwMDCwcBCAoLBwEICgMDAwMDBwgMAQsHAQgKAQYIAwEDAgYIAwUBCAkBBgsLAggJBQELDgEFAwoLCAEICgsFAQMHCAwCAwgVAgoIEgcIDAEIFQEGCBUBCBECBQsOAQUBCw0CCQAJAQEICgELBwEJAAEHCAwBCAYXAwMDAwMIBggAAwMBCwcBCAoDAwsHAQgKCA8DCAYIEQMDCw0CBQsOAQUDCBUBCBIBBggMAQUQBQoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgMAwcIFQgSBwgMAgcIFQcIDAMHCBUDBwgMAQYKCBIBCBQDBwgVBggTAgMHCBUGCBQBAQcIEgMHCBIIFAMDBwgVAwYIDAIHCBUGCAwCBwgSAwELCAEJAAQHCBUFCwcBCAoHCAwBBggQAwcIFQgQBwgMAgYIFQUBAQQGBQYFBQcLDgEFAQYIFAEGBQIGCw0CCQAJAQYJAAEJAAELDgEJAAMHCw0CCQAJAQkACQECBwsNAgkACQEGCQABBwkBAgYLDgEJAAYJAAIHCw4BCQAJAAIHCw4BCQAGCQABBgsOAQkAAgkACQECBwgSBwgMAgcIEgoCAgcIEgYIEgIGCBUGCBIDBwgSCgIKAiwBAwMDAwMDAQEBCwcBCAoDAwMDAwMDAwQDAwMLBwEICgMDAwsHAQgKCwcBCAoLBwEICgsHAQgKAwMDCwcBCAoECwcBCAoEAwMDAwQDAQcLBwEJAAIHCwcBCQALBwEJAAEGCBEBBgsHAQkAAQcIDwIHCwcBCQADCQcIFQcLBwEICgcLBwEICgcLDQIFCw4BBQMDAwMHCAwGBwgRCwcBCAoLBwEICgsHAQgKAwMBCAQBBgkBBQsHAQgKAwsHAQgKCwgBCAoLBwEICgELCAEICgIHCwgBCQAKCwgBCQABBgsFAQkAAQsFAQkAAgsHAQkABwgMAgkABQNCYWcHQmFsYW5jZQRDb2luAklEBk9wdGlvbgNTVUkMU3Rha2VTdWJzaWR5CVN0YWtlZFN1aQtTdG9yYWdlRnVuZBNTdWlTeXN0ZW1TdGF0ZUlubmVyFVN1aVN5c3RlbVN0YXRlSW5uZXJWMhRTeXN0ZW1FcG9jaEluZm9FdmVudBBTeXN0ZW1QYXJhbWV0ZXJzElN5c3RlbVBhcmFtZXRlcnNWMgVUYWJsZQlUeENvbnRleHQfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAlWYWxpZGF0b3IVVmFsaWRhdG9yT3BlcmF0aW9uQ2FwDFZhbGlkYXRvclNldAZWZWNNYXAGVmVjU2V0EWFjdGl2ZV92YWxpZGF0b3JzDWFkdmFuY2VfZXBvY2gmYXNzZXJ0X25vX3BlbmRpbmdfb3JfYWN0aXZlX2R1cGxpY2F0ZXMDYmFnB2JhbGFuY2UEY29pbghjb250YWlucwZjcmVhdGUYY3JlYXRlX3N5c3RlbV9wYXJhbWV0ZXJzGmRlcml2ZV9yZWZlcmVuY2VfZ2FzX3ByaWNlDGRlc3Ryb3lfc29tZQxkZXN0cm95X3plcm8EZW1pdAVlbXB0eQVlcG9jaBFlcG9jaF9kdXJhdGlvbl9tcxhlcG9jaF9zdGFydF90aW1lc3RhbXBfbXMFZXZlbnQMZXh0cmFfZmllbGRzFGV4dHJhY3RfY29pbl9iYWxhbmNlDGZyb21fYmFsYW5jZQdnZW5lc2lzHGdlbmVzaXNfc3lzdGVtX3N0YXRlX3ZlcnNpb24DZ2V0B2dldF9tdXQQZ2V0X3JlcG9ydGVyc19vZh9nZXRfc3RvcmFnZV9mdW5kX29iamVjdF9yZWJhdGVzHmdldF9zdG9yYWdlX2Z1bmRfdG90YWxfYmFsYW5jZRpnZXRfdmFsaWRhdG9yX211dF93aXRoX2N0eC9nZXRfdmFsaWRhdG9yX211dF93aXRoX2N0eF9pbmNsdWRpbmdfY2FuZGlkYXRlcyNnZXRfdmFsaWRhdG9yX211dF93aXRoX3ZlcmlmaWVkX2NhcAZpbnNlcnQMaW50b19iYWxhbmNlImlzX2FjdGl2ZV92YWxpZGF0b3JfYnlfc3VpX2FkZHJlc3MIaXNfZW1wdHkHaXNfc29tZQRqb2luCGpvaW5fdmVjHGxlZnRvdmVyX3N0b3JhZ2VfZnVuZF9pbmZsb3cTbWF4X3ZhbGlkYXRvcl9jb3VudBNtaW5fdmFsaWRhdG9yX2NvdW50G21pbl92YWxpZGF0b3Jfam9pbmluZ19zdGFrZQNuZXczbmV3X3VudmVyaWZpZWRfdmFsaWRhdG9yX29wZXJhdGlvbl9jYXBfYW5kX3RyYW5zZmVyGm5leHRfZXBvY2hfdmFsaWRhdG9yX2NvdW50Bm9iamVjdAZvcHRpb24KcGFyYW1ldGVycwNwYXkQcHJvdG9jb2xfdmVyc2lvbg9wdWJsaWNfdHJhbnNmZXITcmVmZXJlbmNlX2dhc19wcmljZQZyZW1vdmUQcmVwb3J0X3ZhbGlkYXRvchVyZXBvcnRfdmFsaWRhdG9yX2ltcGwRcmVxdWVzdF9hZGRfc3Rha2UacmVxdWVzdF9hZGRfc3Rha2VfbXVsX2NvaW4VcmVxdWVzdF9hZGRfdmFsaWRhdG9yH3JlcXVlc3RfYWRkX3ZhbGlkYXRvcl9jYW5kaWRhdGUYcmVxdWVzdF9yZW1vdmVfdmFsaWRhdG9yInJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvcl9jYW5kaWRhdGUbcmVxdWVzdF9zZXRfY29tbWlzc2lvbl9yYXRlFXJlcXVlc3Rfc2V0X2dhc19wcmljZRZyZXF1ZXN0X3dpdGhkcmF3X3N0YWtlFHJvdGF0ZV9vcGVyYXRpb25fY2FwCXNhZmVfbW9kZR1zYWZlX21vZGVfY29tcHV0YXRpb25fcmV3YXJkcyRzYWZlX21vZGVfbm9uX3JlZnVuZGFibGVfc3RvcmFnZV9mZWUZc2FmZV9tb2RlX3N0b3JhZ2VfcmViYXRlcxlzYWZlX21vZGVfc3RvcmFnZV9yZXdhcmRzBnNlbmRlch1zZXRfY2FuZGlkYXRlX2NvbW1pc3Npb25fcmF0ZRdzZXRfY2FuZGlkYXRlX2dhc19wcmljZSdzZXRfY2FuZGlkYXRlX3ZhbGlkYXRvcl9jb21taXNzaW9uX3JhdGUhc2V0X2NhbmRpZGF0ZV92YWxpZGF0b3JfZ2FzX3ByaWNlCXNpbmdsZXRvbgVzcGxpdBZzdGFrZV9hY3RpdmF0aW9uX2Vwb2NoDXN0YWtlX3N1YnNpZHkUc3Rha2Vfc3Vic2lkeV9hbW91bnQZc3Rha2Vfc3Vic2lkeV9zdGFydF9lcG9jaAxzdGFraW5nX3Bvb2wVc3Rha2luZ19wb29sX21hcHBpbmdzDnN0b3JhZ2VfY2hhcmdlDHN0b3JhZ2VfZnVuZBRzdG9yYWdlX2Z1bmRfYmFsYW5jZRlzdG9yYWdlX2Z1bmRfcmVpbnZlc3RtZW50DnN0b3JhZ2VfcmViYXRlA3N1aQpzdWlfc3lzdGVtFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIUc3lzdGVtX3N0YXRlX3ZlcnNpb24FdGFibGUNdG90YWxfYmFsYW5jZQ50b3RhbF9nYXNfZmVlcxx0b3RhbF9vYmplY3Rfc3RvcmFnZV9yZWJhdGVzC3RvdGFsX3N0YWtlH3RvdGFsX3N0YWtlX3Jld2FyZHNfZGlzdHJpYnV0ZWQIdHJhbnNmZXIKdHhfY29udGV4dBV1bmRvX3JlcG9ydF92YWxpZGF0b3IadW5kb19yZXBvcnRfdmFsaWRhdG9yX2ltcGwgdXBkYXRlX2NhbmRpZGF0ZV9uZXR3b3JrX2FkZHJlc3MfdXBkYXRlX2NhbmRpZGF0ZV9uZXR3b3JrX3B1YmtleRx1cGRhdGVfY2FuZGlkYXRlX3AycF9hZGRyZXNzIHVwZGF0ZV9jYW5kaWRhdGVfcHJpbWFyeV9hZGRyZXNzIHVwZGF0ZV9jYW5kaWRhdGVfcHJvdG9jb2xfcHVia2V5KnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX25ldHdvcmtfYWRkcmVzcyl1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9uZXR3b3JrX3B1YmtleSZ1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wMnBfYWRkcmVzcyp1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wcmltYXJ5X2FkZHJlc3MqdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcHJvdG9jb2xfcHVia2V5KXVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3dvcmtlcl9hZGRyZXNzKHVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3dvcmtlcl9wdWJrZXkfdXBkYXRlX2NhbmRpZGF0ZV93b3JrZXJfYWRkcmVzcx51cGRhdGVfY2FuZGlkYXRlX3dvcmtlcl9wdWJrZXkSdXBkYXRlX2Rlc2NyaXB0aW9uEHVwZGF0ZV9pbWFnZV91cmwLdXBkYXRlX25hbWUhdXBkYXRlX25leHRfZXBvY2hfbmV0d29ya19hZGRyZXNzIHVwZGF0ZV9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5HXVwZGF0ZV9uZXh0X2Vwb2NoX3AycF9hZGRyZXNzIXVwZGF0ZV9uZXh0X2Vwb2NoX3ByaW1hcnlfYWRkcmVzcyF1cGRhdGVfbmV4dF9lcG9jaF9wcm90b2NvbF9wdWJrZXkgdXBkYXRlX25leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MfdXBkYXRlX25leHRfZXBvY2hfd29ya2VyX3B1YmtleRJ1cGRhdGVfcHJvamVjdF91cmwcdXBkYXRlX3ZhbGlkYXRvcl9kZXNjcmlwdGlvbhp1cGRhdGVfdmFsaWRhdG9yX2ltYWdlX3VybBV1cGRhdGVfdmFsaWRhdG9yX25hbWUrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX25ldHdvcmtfYWRkcmVzcyp1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfbmV0d29ya19wdWJrZXkndXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3AycF9hZGRyZXNzK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wcmltYXJ5X2FkZHJlc3MrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleSp1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MpdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3dvcmtlcl9wdWJrZXkcdXBkYXRlX3ZhbGlkYXRvcl9wcm9qZWN0X3VybAh2MV90b192Mgl2YWxpZGF0b3INdmFsaWRhdG9yX2NhcCB2YWxpZGF0b3JfbG93X3N0YWtlX2dyYWNlX3BlcmlvZB12YWxpZGF0b3JfbG93X3N0YWtlX3RocmVzaG9sZBh2YWxpZGF0b3JfcmVwb3J0X3JlY29yZHMNdmFsaWRhdG9yX3NldBZ2YWxpZGF0b3Jfc3Rha2VfYW1vdW50GXZhbGlkYXRvcl9zdGFraW5nX3Bvb2xfaWQfdmFsaWRhdG9yX3N0YWtpbmdfcG9vbF9tYXBwaW5ncxx2YWxpZGF0b3JfdG90YWxfc3Rha2VfYW1vdW50InZhbGlkYXRvcl92ZXJ5X2xvd19zdGFrZV90aHJlc2hvbGQKdmFsaWRhdG9ycwV2YWx1ZQd2ZWNfbWFwB3ZlY19zZXQedmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzCnZlcmlmeV9jYXAMd2l0aGRyYXdfYWxsBHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAQECAQICAQMDCAEAAAAAAAAAAwgAAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAMIBQAAAAAAAAADCAYAAAAAAAAAAwgHAAAAAAAAAAMICAAAAAAAAAAEEBAnAAAAAAAAAAAAAAAAAAAAAgglA2YDPQM/A6QBA6sBA6MBAygIBgECCSUDZgM+Az0DPwOkAQOrAQOjAQMoCAYCAhAkA0cDcQOsAQgVaggRRQgASQOlAQsNAgULDgEFZAgPVwFbCwcBCApYCwcBCApaA1kDJgMoCAYDAhAkA0cDcQOsAQgVaggRRQgBSQOlAQsNAgULDgEFZAgPVwFbCwcBCApYCwcBCApaA1kDJgMoCAYEAgwkA0cDSQN2A2wDaQNtA2sDZQN0A3cDPAMAAwAAGhsLAAoGEXQMCA4IEW8MBwYAAAAAAAAAAAsCESkLCAsBEVELBAsHOAALBQk4ATgBBgAAAAAAAAAABgAAAAAAAAAACwMLBhE0EgICAQMAAAYLCwALAQsCCwMLBAsFCwYLBxE0EgACAgMAACU3CwATAgwRDAMMDAwNDAsMDgwKDA8MFQwJDAcMEgwXAQwIDAELBxMADAYMEwwWDBQMBQwEDBAMAgsBCwgGAgAAAAAAAAALFwsSCwILEAYEAAAAAAAAAAsECwULFAsWCxMLBhIBCwkLFQsPCwoLDgsLCw0LDAsDCxESAwIDAwAAJhoKDy4RQQsBCwILAwsECwULBgsHCwgLCQsKCwsLDAsNCw4KDxFUDBALAA8ACxALDxF4AgQDAAAGBQsADwALARF6AgUDAAAGGQoAEAARdQoAEAEQAhQjBAoFEAsAAQsBAQcDJwoADwALABABEAMUCwERdwIGAwAABh8KABAAEWxBJgoAEAEQBBQmBBoKABAAEXUKABABEAQUJAQUBRoLAAELAQEHAycLAA8ACwEReQIHAwAALg8KAA8ACwEHARGBAQwDCwAPAA4DCRFyCwMLAhFWAggDAAAuDwoADwALAQcCEYEBDAMLAA8ADgMIEXILAwsCEVgCCQMAAAYHCwAPAAsBCwIuEXsCCgMAAAYICwAPAAsCLhFxCwERVwILAwAABggLAA8ACwILATgCCwMRdgIMAwAAEgwLAQsCCgQRMQwFCwAPAAsDCwULBBF2Ag0DAAAGFA4BEU8KAi4RQCUECAUOCwABCwIBBwknCwAPAAsBCwIRfAIOAwAABhYKABAACgIRcwQGBQwLAAELAQEHBCcKAA8ACwEHABGBAQsCCwAPBREQAg8DAAAGCgoADwALAQcAEYEBCwILAA8FERECEAAAADwuDgARaxQMBQoFCgEiBAkFDQsCAQcGJwoCDgEMAy4LAzgDIAQbCwILAQsFOAQ4BQUtCwIOATgGDAYKBg4FDAQuCwQ4ByAEKwsGCwU4CAUtCwYBAhEAAAA8MgoCDgEMAy4LAzgDBAgFDAsCAQcHJwoCDgE4BgwGDgARaxQMBQoGDgUMBC4LBDgHBBwFIgsCAQsGAQcHJwoGDgU4CQsGLjgKBC8LAg4BOAsBAQUxCwIBAhIDAAAGCAsADwAKAS4RcQsBEVUCEwMAAAYHCwAPAAsCEXELARFiAhQDAAAGBwsADwALAhFxCwERYAIVAwAABgcLAA8ACwIRcQsBEWECFgMAAAYHCwAPAAsCEXELARFqAhcDAABMEAoADwALAhFwDAMKAwsBEWMLAy4MBAsAEAALBBFuAhgDAAAGBwsADwALAhFxCwERWQIZAwAATBAKAA8ACwIRcAwDCgMLARFlCwMuDAQLABAACwQRbgIaAwAABgcLAA8ACwIRcQsBEVsCGwMAAAYHCwAPAAsCEXALARFmAhwDAAAGBwsADwALAhFxCwERXAIdAwAABgcLAA8ACwIRcAsBEWgCHgMAAAYHCwAPAAsCEXELARFeAh8DAABMEQoADwALAxFwDAQKBAsBCwIRZwsELgwFCwAQAAsFEW4CIAMAAAYICwAPAAsDEXELAQsCEV0CIQMAAEwQCgAPAAsCEXAMAwoDCwERaQsDLgwECwAQAAsEEW4CIgMAAAYHCwAPAAsCEXELARFfAiMDAABMEAoADwALAhFwDAMKAwsBEWQLAy4MBAsAEAALBBFuAiQDAAAGBwsADwALAhFxCwERWgIlAwAAT9ACCgAQBhQMJQoJCgAPBhUHDDQMHAoHChwlBBQKCAscJQwLBRYJDAsLCwQZBR8LAAELCgEHCCcKAA8HOAwMKA0DCyg4DQEKAA8IOAwMJw0ECyc4DQELBQoAEAkUFgwFBgAAAAAAAAAACgAPCRULBgoAEAoUFgwGBgAAAAAAAAAACgAPChUKABAAEX4MNgoAEAsRUgwsCiwLNhYMNA4DOA4MKw4EOA4MHQoKLhFACgAQARAMFCYEaAsJCyUKABABEA0UFiYMFAVqCQwUCxQEcQoADw4RTgwVBXM4AQwVCxUMKQ4pOA4MKg0ECyk4DQELNDUMNQodNQweCyw1Cx4YCzUaDDANBAowNDgPDC8LMAsHNRgHDBoMLg0vCi40OA8MLQoAEA8UBgEAAAAAAAAAFgoADw8VCwEKABAPFCEEqQEFrwELAAELCgEHCycOBDgODCAOLzgODDIKAA8ADQQNLwoADwULCAoAEAEQEBQKABABEBEUCgAQARASFAsKEW0KABAAEX4MJA4EOA4MHw4vOA4MMQsgCx8XDCELMgsxFwwzCwIKAA8TFQoAEAARbwoADxQVCy8MIg0iCwQ4DQEOIjgODCMKAA8LCwMLLQsiCgULBhFQDCYKABAPFAwWCgAQExQMFwoAEBQUDBgLJAwZCysMGgsuNAwbCwUMDAoAEAsRUgwNCyoMDgsdDA8LIQszFgwQCyMMEQsWCxcLGAsZCxsLGgsMCw0LDgsPCxALERIEOBAJCgAPFRUKABAJFAYAAAAAAAAAACEEugIKABAHOA4GAAAAAAAAAAAhDBIFvAIJDBILEgTFAgsAEAg4DgYAAAAAAAAAACEMEwXJAgsAAQkMEwsTBMwCBc4CBwonCyYCJgMAAAYECwAQDxQCJwMAAAYECwAQExQCKAMAAAYECwAQFhQCKQMAAAYCBwMCKgMAAAYECwAQBhQCKwMAAAYFCwAQAAsBEYABAiwDAAAGBQsAEAALARF/Ai0DAAAGBAsAEAARfQIuAwAAGBIKABAFDgE4AwQMCwAQBQ4BOBEUDAIFEAsAATgSDAILAgIvAwAABgQLABALEVICMAMAAAYECwAQCxFTAjEAAABaLQ0ARVsMBg0GCwA4EwsGOAIMBw4BOBQEJwsBOBUMBA0HCwQ4DwwFDgc4DgYAAAAAAAAAACQEIAsHCgI4FgsCLhFBOBcFJAsCAQsHOBgLBQwDBSsLAgELBwwDCwMCAwMDBQEDAQQBAgMHAw4DCgMLAwwDDQMEAQEBAAMIAwABBQEGAQcDAQMGAwkDAgArAG8AHQ12YWxpZGF0b3JfY2FwH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3JfY2FwFVZhbGlkYXRvck9wZXJhdGlvbkNhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbAtTdGFraW5nUG9vbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbBVQb29sVG9rZW5FeGNoYW5nZVJhdGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wJU3Rha2VkU3VpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJdmFsaWRhdG9yEVZhbGlkYXRvck1ldGFkYXRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJdmFsaWRhdG9yCVZhbGlkYXRvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCXZhbGlkYXRvchNTdGFraW5nUmVxdWVzdEV2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJdmFsaWRhdG9yFVVuc3Rha2luZ1JlcXVlc3RFdmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHZvdGluZ19wb3dlcg9Wb3RpbmdQb3dlckluZm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwx2b3RpbmdfcG93ZXIRVm90aW5nUG93ZXJJbmZvVjIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxF2YWxpZGF0b3Jfd3JhcHBlchBWYWxpZGF0b3JXcmFwcGVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX3NldAxWYWxpZGF0b3JTZXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0F1ZhbGlkYXRvckVwb2NoSW5mb0V2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX3NldBlWYWxpZGF0b3JFcG9jaEluZm9FdmVudFYyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX3NldBJWYWxpZGF0b3JKb2luRXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0E1ZhbGlkYXRvckxlYXZlRXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdG9yYWdlX2Z1bmQLU3RvcmFnZUZ1bmQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw1zdGFrZV9zdWJzaWR5DFN0YWtlU3Vic2lkeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIQU3lzdGVtUGFyYW1ldGVycwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXISU3lzdGVtUGFyYW1ldGVyc1YyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchNTdWlTeXN0ZW1TdGF0ZUlubmVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchVTdWlTeXN0ZW1TdGF0ZUlubmVyVjIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxZzdWlfc3lzdGVtX3N0YXRlX2lubmVyFFN5c3RlbUVwb2NoSW5mb0V2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMKc3VpX3N5c3RlbQ5TdWlTeXN0ZW1TdGF0ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADB2dlbmVzaXMYR2VuZXNpc1ZhbGlkYXRvck1ldGFkYXRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMHZ2VuZXNpcxZHZW5lc2lzQ2hhaW5QYXJhbWV0ZXJzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMHZ2VuZXNpcxlUb2tlbkRpc3RyaWJ1dGlvblNjaGVkdWxlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMHZ2VuZXNpcw9Ub2tlbkFsbG9jYXRpb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQAAAAAAAAADIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCnN1aV9zeXN0ZW0OU3VpU3lzdGVtU3RhdGUAAAEAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAQAAAAAAAAACAQAAAAAAAAAgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFY2xvY2sFQ2xvY2sAAAEAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAACAQAAAAAAAAAgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QEAAAAAAAAABARjbG9ik0mhHOsLBgAAAA0BACMCI3YDmQG5BATSBbYBBYgH5QkH7RCnDgiUH2AG9B+dAgqRIrABC8EjCAzJI78kDYhILA60SBwAKwAzADQAWgFnAYQBAhoCLAItAj4CUgJlAnoCfQKCAQKDAQAOBwAADAcCAAEAAQAKBwIAAQABAAsHAgABAAEACQYAABEEAAANCAIAAQABAQQEAQQAAgAMAAIFDAEAAQQIBwEAAAUTBwAGAQQBAAEHAggACAMMAQABCgcMAgcABAELBgcACxQEAAwPAgANEAwCBwEEAQ8SAgAAOgABAAAvAgMAADEEAQIAAAAwBQECAAAANwYBAgAAADgHAQIAAACJAQgJAgAAAIsBCAoCAAAAewsMAgAAAHwNDAIAAABZDg8CAAAAWA4PAgAAAFcQDwIAAABsERICAAAASxMUAgAAAGsVFgIAAABpFBcAAD0YAQIAAAAqGQECAAAAdxobAgAAACkcAQIAAAAiHQECAAAAUx4fAgAAABYeIAIAAABHISICAAAARiEiAgAAAEUjFAIAAABIJCUCAAABJVQ6AQQBJlQ6AQQBKEZHAQQBQFQUAQQBQVRNAQQBTFsUAQQBT0QXAQQBW0RFAQQBXERFAQQBYAIwAQQBZFRFAQQBblRFAQQBdkYqAQQCFWEUAQACFmFFAQACNVo0AQACNkw0AQACSjwBAQACVFoBAQACXQIDAAJgAjMBAAKGAUwBAQACigE9CQEAAowBPQkBAAM7RU0AA15FFAADX0VNAAQkSToBAARQSRcBAAVEASsBAAZRTxQBAAZ5TjQBAAaIAUEUAQAGjQEBNAEAB4ABQBQACEJCCQEACE0JNAEACFFYAQEACIgBORQBAAk8KgEBAwoZSEkCBwQKJEpLAgcECidTUgIHBAouShcCBwQKOSgBAgcECkNISQIHBApPSBcCBwQKYAIoAgcECmFKSQIHBApwXAECBwQKdVMsAgcEC0k6OwEIC2ACLQALhQEuLwANF18BAgcEDSReSwIHBA0nUVICBwQNLl4XAgcEDWACMgIHBA54KgEBCEgnOSo5LCUAVjEwKjAsPSo9LFc2QzdCOEA4AjVPA0AqLSpALC0sMiozLEIsDTUKNTwqPyo/LCIAJAAeAEknNxRKJ0UnMSosKjsqOio7LENQTCc4FFQxTkVOJ0YnJgAoACAAETUjADEsLCw6LCcACzVBKkIqDDVBLC4sLipLJyEATSdDXVUxS0VSMU1FKSwrLDwsKyoONUNiR0VFRRM1HABHJ0pFREVTMUlFHQBMRSoqKiwfABo1AQgFAAEHCBQBCAgGAwMDAwsMAQgSBwgUBAMDCw4BCBIHCBQDBwsGAgkACQELDgEJAAYICAMHCwYCCQAJAQsOAQkBBggIBAcLBgIJAAkBAwYICAcIFAELDgEJAAELDgEJAQYHCwYCCQAJAQMLDgEJAAsOAQkBBggNBwgUAwsOAQkACw4BCQEDBQcLBgIJAAkBAwYIDQsOAQkBBwgUBQcLBgIJAAkBAwMDCwwBCQECCwwBCQALDAEJAQQHCwYCCQAJAQMDCwwBCQAHBwsGAgkACQEDAQsOAQkACw4BCQEGCA0HCBQCCw4BCQALDgEJAQcHCwYCCQAJAQMDAQMGCAgHCBQBAwkHCwYCCQAJAQMDAQMCBggNBggIBwgUBAMDAQMBAQIIEAYIBAMHCwYCCQAJAQMGCAgFBwsHAQgFBwsPAgMDAwMIEAEIBAIHCwYCCQAJAQYICAMHCwYCCQAJAQoDBggIAgYLBgIJAAkBBggIAQoIBAQDAwMDBAYLBgIJAAkBAwMGCA0CCgMKAwMGCwcBCAUDAwMGCwYCCQAJAQMGCAgBBggEAQsPAgMIBAIDCAQBCw8CCQAJAQQICwgQCBEICwEJAAEICwEJAQEIEQEGCBEBBggQAQsHAQkAAggQCw8CAwMBCxMCCQAJAQELCQEJAAELDAEJAAIJAAkBAQsGAgkACQEBCAABCBIBBgsOAQkAAQYJAAEIEAMHCwkBCQAIEAsMAQkABAcLCQEJAAMGCAgHCBQEAwsOAQkACw4BCQEDAwsMAQkACwwBCQEDAQYIDQEGCwwBCQACCwwBCQAHCBQaAQMBAwMHCwcBCAULDAEJAAMDCwwBCQADBggEBwgEAwMGCwoBAwMDCwwBCQEBAwsMAQkAAwMHCAUDAQYLBwEJAAIDAwIHCwcBCQADAQcJAAEGCw8CCQAJAQEGCwoBCQACBgsPAgkACQEJAAEGCQEDBwsJAQkACBADAgEDAgcLDAEJAAMCBwsMAQkACwwBCQABCwMCCQAJAQIHCxMCCQAJAQkAAQcJAQIHCw8CCQAJAQkAAgYLBwEJAAMaAQMBAwMHCwcBCAULDAEJAAMDCwwBCQADBggEBwgEAwYLCgEDAwMIEAsMAQkBAQMDCwwBCQADBwgFAxsBAwEDAwcLBwEIBQsMAQkAAwMLDAEJAQMGCAQHCAQDAwYLCgEDAwMIEAsMAQkBAQMDCwwBCQEDBwgFAwMLDAEJAAsMAQkBCwwBCQECBwsOAQkACw4BCQAHAwcLBwEIBQgEAwMDCBADBwsJAQkABggIAwMHCwcBCQADCQADBwsPAgkACQEJAAkBAQsBAgkACQECBgsTAgkACQEJAAMHCxMCCQAJAQkACQELCwwBCQALDAEJAAsMAQkAAwMLDAEJAQsMAQkBCwwBCQEDAwgQAgYLCQEJAAgQAQsCAgkACQELAwMGCwcBCAUHCwcBCAUDAQgEAwMIEAcLDwIDAwMDBwgFCAQNAwcLBwEIBQMDAQcLBwEIBQgEAwMIEAMIEAcLDwIDAxIGCwcBCAUDAwYLBwEIBQcLBwEIBQMDAQMDAwgEAwgQAwMIEAcLDwIDAwcGCAUKCAQGCAQGCwoBAwMIEAYLDwIDAwUDAwMDCBAGAwoDAwMDCgMEAwYIBAYLCgEDBgsPAgMIBAMGCwcBCAUDCBAKQWNjb3VudENhcAdCYWxhbmNlBUNsb2NrBENvaW4LQ3JpdGJpdFRyZWUJQ3VzdG9kaWFuAklEC0xpbmtlZFRhYmxlBk9wdGlvbgVPcmRlcg1PcmRlckNhbmNlbGVkC09yZGVyRmlsbGVkC09yZGVyUGxhY2VkBFBvb2wLUG9vbENyZWF0ZWQDU1VJBVRhYmxlCVRpY2tMZXZlbAlUeENvbnRleHQIVHlwZU5hbWUDVUlEGWFjY291bnRfYXZhaWxhYmxlX2JhbGFuY2UPYWNjb3VudF9iYWxhbmNlA2FkZARhc2tzBGJhY2sHYmFsYW5jZQpiYXNlX2Fzc2V0HGJhc2VfYXNzZXRfcXVhbnRpdHlfY2FuY2VsZWQaYmFzZV9hc3NldF9xdWFudGl0eV9maWxsZWQaYmFzZV9hc3NldF9xdWFudGl0eV9wbGFjZWQdYmFzZV9hc3NldF9xdWFudGl0eV9yZW1haW5pbmcXYmFzZV9hc3NldF90cmFkaW5nX2ZlZXMOYmFzZV9jdXN0b2RpYW4SYmF0Y2hfY2FuY2VsX29yZGVyBGJpZHMGYm9ycm93FGJvcnJvd19sZWFmX2J5X2luZGV4EmJvcnJvd19sZWFmX2J5X2tleQpib3Jyb3dfbXV0GGJvcnJvd19tdXRfbGVhZl9ieV9pbmRleBFjYW5jZWxfYWxsX29yZGVycwxjYW5jZWxfb3JkZXIEY2xvYgVjbG9jawRjb2luCGNvbnRhaW5zDmNyZWF0ZV9hY2NvdW50C2NyZWF0ZV9wb29sDGNyZWF0ZV9wb29sXwxjcmVhdGlvbl9mZWUHY3JpdGJpdAljdXN0b2RpYW4fZGVjcmVhc2VfdXNlcl9hdmFpbGFibGVfYmFsYW5jZRxkZWNyZWFzZV91c2VyX2xvY2tlZF9iYWxhbmNlDGRlcG9zaXRfYmFzZQ1kZXBvc2l0X3F1b3RlDWRlc3Ryb3lfZW1wdHkTZGVzdHJveV9lbXB0eV9sZXZlbAlkaXZfcm91bmQEZW1pdBNlbWl0X29yZGVyX2NhbmNlbGVkBWV2ZW50EGV4cGlyZV90aW1lc3RhbXAQZmluZF9jbG9zZXN0X2tleQlmaW5kX2xlYWYMZnJvbV9iYWxhbmNlBWZyb250A2dldBZnZXRfbGV2ZWwyX2Jvb2tfc3RhdHVzH2dldF9sZXZlbDJfYm9va19zdGF0dXNfYXNrX3NpZGUfZ2V0X2xldmVsMl9ib29rX3N0YXR1c19iaWRfc2lkZRBnZXRfb3JkZXJfc3RhdHVzAmlkH2luY3JlYXNlX3VzZXJfYXZhaWxhYmxlX2JhbGFuY2USaW5qZWN0X2xpbWl0X29yZGVyC2luc2VydF9sZWFmDGludG9fYmFsYW5jZQZpc19iaWQIaXNfZW1wdHkHaXNfbm9uZQRqb2luDGxpbmtlZF90YWJsZRBsaXN0X29wZW5fb3JkZXJzDGxvY2tfYmFsYW5jZQhsb3Rfc2l6ZRFtYWtlcl9yZWJhdGVfcmF0ZQltYXRjaF9hc2sJbWF0Y2hfYmlkHW1hdGNoX2JpZF93aXRoX3F1b3RlX3F1YW50aXR5BG1hdGgIbWF4X2xlYWYIbWluX2xlYWYQbWludF9hY2NvdW50X2NhcANtdWwJbXVsX3JvdW5kA25ldwRuZXh0EW5leHRfYXNrX29yZGVyX2lkEW5leHRfYmlkX29yZGVyX2lkCW5leHRfbGVhZgZvYmplY3QLb3Blbl9vcmRlcnMGb3B0aW9uCG9yZGVyX2lkDG9yZGVyX2lzX2JpZAVvd25lchFwbGFjZV9saW1pdF9vcmRlchJwbGFjZV9tYXJrZXRfb3JkZXIHcG9vbF9pZA1wcmV2aW91c19sZWFmBXByaWNlCXB1c2hfYmFjawhxdWFudGl0eQtxdW90ZV9hc3NldBhxdW90ZV9hc3NldF90cmFkaW5nX2ZlZXMPcXVvdGVfY3VzdG9kaWFuBnJlbW92ZRRyZW1vdmVfbGVhZl9ieV9pbmRleAxyZW1vdmVfb3JkZXIMc2hhcmVfb2JqZWN0BXNwbGl0A3N1aRlzd2FwX2V4YWN0X2Jhc2VfZm9yX3F1b3RlGXN3YXBfZXhhY3RfcXVvdGVfZm9yX2Jhc2UFdGFibGUOdGFrZXJfZmVlX3JhdGUJdGlja19zaXplDHRpbWVzdGFtcF9tcw50b3RhbF9xdWFudGl0eQh0cmFuc2Zlcgp0eF9jb250ZXh0CXR5cGVfbmFtZQx1aWRfYXNfaW5uZXIOdW5sb2NrX2JhbGFuY2UPdXNyX29wZW5fb3JkZXJzBXZhbHVlDXdpdGhkcmF3X2Jhc2UTd2l0aGRyYXdfYmFzZV9hc3NldA53aXRoZHJhd19xdW90ZRR3aXRoZHJhd19xdW90ZV9hc3NldAR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAMIBQAAAAAAAAADCAYAAAAAAAAAAwgHAAAAAAAAAAMICAAAAAAAAAADCAkAAAAAAAAAAwgKAAAAAAAAAAMICwAAAAAAAAADCAwAAAAAAAAAAwgNAAAAAAAAAAMIDwAAAAAAAAADCBAAAAAAAAAAAwgRAAAAAAAAAAMIEgAAAAAAAAADCBMAAAAAAAAAAwgUAAAAAAAAAAMIFQAAAAAAAAADCBYAAAAAAAAAAgEEAgEAAgEBAgECAgEDAwgAAAAAAAAAAAMIAAAAAAAAAIADCEBLTAAAAAAAAwigJSYAAAAAAAMIAOh2SBcAAAADCADKmjsAAAAAAAIHbQgQGwgLcggLfgNWA38DVQMBAgZtCBBoA04BaggQHgNvAwICBm0IEGgDTgFqCBAcA28DAwIIbQgQaANOAWoIEIEBAx0DHwNvAwQCBmgDbwNxA04BaggQPwMFAgJvA2YLDwIDCAQGAg9JCBEjCwcBCAUYCwcBCAVjA2IDhwELEwIIEAsPAgMDfgNWA38DVQMhCwkBCQB0CwkBCQEyCwwBCBIgCwwBCQBzCwwBCQEGNQM1ATUCNQAAAAAmBwsAEwUMAQELATgAAgEBAAABAwsAES8CAgAAACk9OAEMBjgCDAkKBgoJIgQJBQ0LBQEHDycKAAoBJgQSBRYLBQEHAScKBRFQDAgOCBFRFAwHCwgKBTgDCgU4AwcaBxsKBTgECgAKAQoCCgMKBTgFCwU4BgsEOAc4CDkAOAkLBwsGCwkLAAsBCwILAxIAOAoCAwEAAAETDgI4CwceIQQGBQoLAwEHEycHHAcdCwALAQsCOAwLAzgNAgQBAAABCAsANgALAjgOCwE4DzgQAgUBAAABCAsANgELAjgOCwE4ETgSAgYBAAABBwsANgALAQsCCwM4EwIHAQAAAQcLADYBCwELAgsDOBQCCAEAAD4WDgM4FQwGCwALAQkLAgsDCwQLBTgWDAgMBw4IOBUMCQsHCwgLCQsGFwIJAQAAPxULAAsBBxsLAhE+CwM4ETgXDAYMBQ4FOBgMBwsFCgQ4GQsGCwQ4GgsHAgoAAABDrQILAQwbOAcMCwsEDBcKADYCDAoKCi44GwQUCwABCwoBCwsLFwIKCi44HAwcDB4KCi44GyAEJAUfCh4KAiUMBQUmCQwFCwUEqgIKCgocOB0MHQodEAM4HjgfFAwWCh0QAzggIASIAgU4Ch0QAwoWOCEMEAoQEAQUDA8JDBgKEBAFFAoDJQRVCAwYCgA2AAoQEAYUChAQBBQ4IgXLAQoPChAQBxQRNgwSBGALEgYBAAAAAAAAABYMEgobChImBGcLEgwGBWkKGwwGCwYMDQoNChAQBxQRNAwMBHYLDAYBAAAAAAAAABYMDAoMCgA3AxQRNQwTCgwKADcEFBE2DBkEhwELGQYBAAAAAAAAABYMGQsPCgwXDA8LGwoNFwwbCgA2AAoQEAYUCgw4IwwODQ4LGTgkDBoKADYAChAQBhQNGgsTOCQ4EAoANgULGjglAQ0LCw44JQEKADYBChAQBhQNFwsNOCY4EgoANwYRURQKEBAMFAkKEBAGFAoQEAQUCwwKDwoQEAcUOQE4JwsYBNABCAwHBdQBCg8GAAAAAAAAAAAhDAcLBwT3AQoWDBUKHRADChY4KAwUChQ4KSAE5gELFDgfFAwWBegBCxQBCgA2BwsQEAYUOCoKFTgrAQodDwMLFTgsAQWCAgsQAQodDwMKFjgtDBELDwsRDwQVChsGAAAAAAAAAAAhBIcCBYgCBTILHRADOCAEoAIKCgseDAguCwg4LgEMHgoKCxw4LxEACgoKHgwJLgsJODAMHAEKGwYAAAAAAAAAACEEqQILAAELCgEFqgIFGQsLCxcCCwAAAFWiAgoANwYRURQMFgsBDBk4BwwLCwQMFwoANgIMCgoKLjgbBBkLAAELCgELCwsXAgoKLjgcDBwMHgoKLjgbIAQpBSQKHgoCJQwFBSsJDAULBQSfAgoKChw4HQwdCh0QAzgeOB8UDBUKHRADOCAgBP0BBT0KHRADChU4IQwQChAQBBQMDwkMGAoQEAUUCgMlBF0IDBgKADYAChAQBhQKEBAEFDgiChYKEDgxBcABChkKDyYEZAoPDAYFZgoZDAYLBgwMCgwKEBAHFBE1DA0KDAoANwMUETUMEgoMCgA3BBQRNgwaBH8LGgYBAAAAAAAAABYMGgsPCgwXDA8LGQoMFwwZCgA2AAoQEAYUCgw4IwwODQ4LGjgkDBsKADYAChAQBhQNGwsSOCQ4EAoANgULGzglAQ0LCw44JQEKADYBChAQBhQNFwsNOCY4EgoWChAQDBQJChAQBhQKEBAEFAsMCg8KEBAHFDkBOCcLGATFAQgMBwXJAQoPBgAAAAAAAAAAIQwHCwcE7AEKFQwUCh0QAwoVOCgMEwoTOCkgBNsBCxM4HxQMFQXdAQsTAQoANgcLEBAGFDgqChQ4KwEKHQ8DCxQ4LAEF9wELEAEKHQ8DChU4LQwRCw8LEQ8EFQoZBgAAAAAAAAAAIQT8AQX9AQU3Cx0QAzggBJUCCgoLHgwILgsIOC4BDB4KCgscOC8RAAoKCh4MCS4LCTgwDBwBChkGAAAAAAAAAAAhBJ4CCwABCwoBBZ8CBR4LCwsXAgwAAABWqgIKADcGEVEUDBYLAwwKOAgMFwoANggMCQoJLjgbBBcLAAELCQELCgsXAgoJLjgyDBwMHgoJLjgbIAQnBSIKHgoBJgwEBSkJDAQLBASnAgoJChw4HQwdCh0QAzgeOB8UDBUKHRADOCAgBIQCBTsKHRADChU4IQwPCg8QBBQMDgkMGAoPEAUUCgIlBGEIDBgKDxAEFAoPEAcUETUMEQoANgEKDxAGFAsRODMKFgoPODEFxgEOCjgYDBkKGQoOJgRrCg4MBQVtCxkMBQsFDAsKCwoPEAcUETUMDAoMCgA3AxQRNQwSCgwKADcEFBE2DBoEhgELGgYBAAAAAAAAABYMGgsOCgsXDA4KADYBCg8QBhQLDDg0DA0NDQsaOCYMGwoANgEKDxAGFA0bCxI4JjgSCgA2CQsbODUBDRcLDTg1AQoANgAKDxAGFA0KCgs4JDgQCgA3BhFRFAoPEAwUCAoPEAYUCg8QBBQLCwoOCg8QBxQ5ATgnCxgEywEIDAYFzwEKDgYAAAAAAAAAACEMBgsGBPIBChUMFAodEAMKFTgoDBMKEzgpIAThAQsTOB8UDBUF4wELEwEKADYHCw8QBhQ4KgoUOCsBCh0PAwsUOCwBBf0BCw8BCh0PAwoVOC0MEAsOCxAPBBUOCjgYBgAAAAAAAAAAIQSDAgWEAgU1Cx0QAzggBJwCCgkLHgwHLgsHODYBDB4KCQscOC8RAAoJCh4MCC4LCDgwDBwBDgo4GAYAAAAAAAAAACEEpgILAAELCQEFpwIFHAsKCxcCDQEAAFdICgEKADcKFBkGAAAAAAAAAAAhBAkFEQsAAQsGAQsFAQcFJwsCBCcLAAsBBxsLBRE+CwQ4ETg3DAkMBw0DCwcKBjgZODgLCQsGOBoMBAVFCwEOAzg5JQQtBTULAAELBgELBQEHEScLAAcaCwURPgsDOA84OgwICgY4GQwDDQQLCAsGOBo4OwsDCwQCDgAAAFl1CgU4DgwNCgMEHgoCCgERNQwLCgA2AQsFCws4PAoANwsUDAoKADcLFAYBAAAAAAAAABYKADYLFQoANggMCAUyCgA2AAsFCgI4PQoANwwUDAoKADcMFAYBAAAAAAAAABYKADYMFQoANgIMCAoKCgEKAgoDCg0LBBIEDAkKCAoBDAcuCwc4MAwMIARLCggKAQoBCgY4PhIFOD8MDAsICww4HQ8DCgoLCThACgA3BhFRFAoKCwMKDQsCCgE5AjhBCgA3BwoNOEIgBGoKADYHCg0LBjhDOEQFbAsGAQsANgcLDTgqCgoLAThFCwoCDwEAAGDyAQoCBgAAAAAAAAAAJAQFBQ8LAAELCAELBgELBwEHBScKAQoANw0UGQYAAAAAAAAAACEEGAUiCwABCwgBCwYBCwcBBwQnCgIKADcKFBkGAAAAAAAAAAAhBCsFNQsAAQsIAQsGAQsHAQcFJwoECgYRPiQEOwVFCwABCwgBCwYBCwcBBxQnCgc4DgwTCgMEcQoANwEKEzhGDBIKADYBCgcKEjhHDA4KAAoCCgELBhE+Cw44NwwQDAoOCjgYDAwLEg4QOEgXDBEKADYAChMLCjgQCgA2AQsTCxA4EgWRAQoANgAKBwoCOEkMCQoACgELBhE+Cwk4OgwPDAsKAg4LOBgXDAwODzhIDBEKADYAChMLCzgQCgA2AQsTCw84EgoFBxchBKABCwABCwgBCwcBCwwLEQkGAAAAAAAAAAACCgUHGCEEtgELAAELCAELBwEKDAsCIQSvAQWxAQcIJwsMCxEJBgAAAAAAAAAAAgoFBxkhBNUBCgwGAAAAAAAAAAAhBL8BBccBCwABCwgBCwcBBwknCwALAQsCCwMLBAsHCwg4SgwNCwwLEQgLDQILBQcWIQTaAQXiAQsAAQsIAQsHAQcNJwsACwELAgoMFwsDCwQLBwsIOEoMDQsMCxEICw0CEAAAAAEECwAHGyMCEQAAAAETCwAKARAMFAoBEBQUCgEQBhQKARAEFAsBEAcUOQM4SwISAQAAY24LAjgODAwKADcHCgw4QgQJBQ0LAAEHCycKADYHCgw4KgwNCg0KAQwDLgsDOEwEGgUgCw0BCwABBwInCg0KAQwELgsEOE0UDAsKAREQDAgKCAQxCgA3CAwFBTQKADcCDAULBQsLODAMCgQ6BUALDQELAAEHAicKCARGCgA2CAwGBUkKADYCDAYLBgsNCwoLAQoMOE4MCQsIBGAOCRAEFA4JEAcUETUMBwoANgELDAsHODMFZwoANgALDA4JEAQUOCILADcGEVEUDgk4MQITAAAAZDYLAQoDOCsBCgAKAgwFLgsFOE8QAwoDOFAEDwUTCwABBwInCgAKAjgdDAYKBg8DCwM4LAwHDgcQBhQLBCEEIwUpCwABCwYBBwMnCwYQAzggBDILAAsCOC8RAAU0CwABCwcCFAEAAGVoCgA3BhFRFAwLCwE4DgwNCgA3BwoNOEIEDgUSCwABBgAAAAAAAAAAJwoANgcKDTgqDA4KDi44USAEYwUdCg4uOFI4HxQMCQoOCgkMAi4LAjhNFAwKCgkREAwGCgYENAoANggMAwU3CgA2AgwDCwMMBwoHCwoMBC4LBDgwDAwBCwcKDgsMCwkKDThODAgLBgRYDggQBBQOCBAHFBE1DAUKADYBCg0LBTgzBV8KADYACg0OCBAEFDgiCgsOCDgxBRcLDgELAAECFQEAAGakAQoANwYRURQMEAsCOA4MEwoANwcKEzhCBA4FEgsAAQYAAAAAAAAAACcGAAAAAAAAAAAMEQoANwg4GyAEHQoANwgMAwUgCgA3AgwDCwMKEThPEBUUDBIOAUEUDAsGAAAAAAAAAAAMCQoANgcKEzgqDBQKCQoLIwSfAQU1DgEKCUIUFAwPChQKDwwELgsEOEwEQgVICxQBCwABBwInChQKDwwFLgsFOE0UDA0KDxEQDAoKDQoSIgRwCw0MEgoKBF8KADcIDAYFYgoANwIMBgsGChI4MAwMBGgFbgsUAQsAAQcKJwsMDBEKCgR2CgA2CAwHBXkKADYCDAcLBwoUChELDwoTOE4MDgsKBJABDg4QBBQODhAHFBE1DAgKADYBChMLCDgzBZcBCgA2AAoTDg4QBBQ4IgoQDg44MQsJBgEAAAAAAAAAFgwJBTALFAELAAECFgEAAGdUCwE4DgwHCgA3BwsHOFMMCEAbAAAAAAAAAAAMAwoIOFQMBQoFOCkgBEwFEgoICgU4HxQ4TRQMBgoFOB8UERAEJAoANwgLBjhVDAIFKQoANwILBjhVDAILAhADCgU4HxQ4IQwEDQMKBBAMFAoEEAcUCgQQBBQKBBAUFAoEEAYUCwQQBRQSBEQbCggLBTgfFDhWDAUFDQsIAQsAAQsFAQsDAhcBAABoFAsBOA4MBgoANwAKBjhXDAMMAgsANwELBjhYDAUMBAsCCwMLBAsFAhgBAABpVgoANwg4HAEMCAoBCggjBAsLCAwBCgA3CDgyAQwHCgIKByQEFgsHDAIKADcICwE4WQwBCgA3CAsCOFkMAkAUAAAAAAAAAAAMCUAUAAAAAAAAAAAMBQoBBgAAAAAAAAAAIQQvCwABCwMBCwkLBQIKAQoCJQRTBTQKADcICgEKAxE+OFoMBA0JCgFEFA0FCwREFAoANwgLATguAQwGCgYGAAAAAAAAAAAhBFALAAELAwEFUwsGDAEFLwsJCwUCGQEAAGlWCgA3AjgcAQwICgEKCCMECwsIDAEKADcCODIBDAcKAgoHJAQWCwcMAgoANwILAThZDAEKADcCCwI4WQwCQBQAAAAAAAAAAAwJQBQAAAAAAAAAAAwFCgEGAAAAAAAAAAAhBC8LAAELAwELCQsFAgoBCgIlBFMFNAoANwIKAQoDET44WgwEDQkKAUQUDQULBEQUCgA3AgsBOC4BDAYKBgYAAAAAAAAAACEEUAsAAQsDAQVTCwYMAQUvCwkLBQIaAAAAajELAAsBOFUQAwwGBgAAAAAAAAAADAMKBjgeDAUKBTgpIAQrBQ8KBgoFOB8UOCEMBAoEEAUUCgIkBCILAwsEEAQUFgwDBSQLBAEKBgsFOB8UOCgMBQUKCwYBCwUBCwMCGwEAAGsdCwI4DgwFCgA3BwsFOFMKAThNFAwECgEHGyMEEwsANwgMAwUWCwA3AgwDCwMLBDhVEAMLATghAgYKBgsGAgUBBAIEBQQEBAEGBwYGBg0GAAQABgUGAQYOBgkGAwYEBggEAwUAADUBNQI1CDUJNQo1CzUNNQ41DzUQNRE1EjUTNQAEbWF0aLECoRzrCwYAAAAHAQACAwIPBREPByAdCD0gBl0cDHmYAQABAAIAAQAAAwACAAAAAAIAAgMDAQMCAQMCBAQDAQQECWRpdl9yb3VuZARtYXRoA211bAltdWxfcm91bmQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QMIAMqaOwAAAAAEEADKmjsAAAAAAAAAAAAAAAAAAQAAAw0LADUMAgsBNQwDCwILAxgHARo0AgEBAAAEGgsANQwDCwE1DAQIDAIKAwoEGAcBGTIAAAAAAAAAAAAAAAAAAAAAIQQSCQwCCwILAwsEGAcBGjQCAgEAAAQcCwA1DAMLATUMBAgMAgoDBwA1GAoEGTIAAAAAAAAAAAAAAAAAAAAAIQQTCQwCCwILAwcANRgLBBo0AgAHY3JpdGJpdNscoRzrCwYAAAAOAQAGAgYcAyLCAQTkATYFmgLrAQeFBJkECJ4IQAbeCHgK1gkzC4kKBAyNCtkRDeYbHA6CHBQPlhwCAA0BKwEsAAIGAQAAAAEGAAAABAEEAAEDDAIHAQQBAgQCAAAfAAEBBAAqAgMBBAAVAgQBBAAeAgUBBAAdAgUBBAAkBgUBBAAhBgUBBAAaBgMBBAAoBgMBBAATBwMBBAARBggBBAAQBgMBBAAmCQoBBAAKCQsBBAAHBgwBBAAIBgwBBAAPAQ0BBgAOAQ0BBAASBgMBBAAtDg0BBAAWDwQBBAAMEBEAAQUaDQIHBAEGFhcCBwQBCRweAgcEAQ4TDQIHBAEPEw0CBwYBFRUEAgcEARsVAwIHBAEfABMCBwQBJRwdAgcEHRIdFBwUGxQCChcUCgoUChcSCAoHChYUEgoWEhMKBgoFCh4UAQoYEhgUHhIOChoSGhQZFBkSAQcIBAELAgEJAAEGCwIBCQABAwEBAgMDAgYLAgEJAAMDBwsCAQkAAwkAAgEDAgcLAgEJAAMBCQABBwkAAQYJAAAEBwsCAQkAAwMBAwYLAgEJAAMDAQQBAgIDCAEBCwMCCQAJAQIDCwABCQABBgsDAgkACQECBgsDAgkACQEJAAEGCQEEAQMDAxADAwMDAwIGCAEBAQgBAwMLAAEJAAMDAwMHCwMCCQAJAQkACQEQAwMDAwMDAwMDAQMDBggBAwMJAAIHCwMCCQAJAQkAAQkBAQcJAQILAwIDCAELAwIDCwABCQACBggBAwICAgtDcml0Yml0VHJlZQxJbnRlcm5hbE5vZGUETGVhZgVUYWJsZQlUeENvbnRleHQDYWRkBmJvcnJvdxRib3Jyb3dfbGVhZl9ieV9pbmRleBJib3Jyb3dfbGVhZl9ieV9rZXkKYm9ycm93X211dBhib3Jyb3dfbXV0X2xlYWZfYnlfaW5kZXgEY2xvYhNjb3VudF9sZWFkaW5nX3plcm9zB2NyaXRiaXQNZGVzdHJveV9lbXB0eQRkcm9wEGZpbmRfY2xvc2VzdF9rZXkJZmluZF9sZWFmHWdldF9jbG9zZXN0X2xlYWZfaW5kZXhfYnlfa2V5C2luc2VydF9sZWFmDmludGVybmFsX25vZGVzCGlzX2VtcHR5DWlzX2xlZnRfY2hpbGQDa2V5BmxlYXZlcwpsZWZ0X2NoaWxkDmxlZnRfbW9zdF9sZWFmBmxlbmd0aARtYXNrCG1heF9sZWFmCG1pbl9sZWFmA25ldxhuZXh0X2ludGVybmFsX25vZGVfaW5kZXgJbmV4dF9sZWFmD25leHRfbGVhZl9pbmRleAZwYXJlbnQNcHJldmlvdXNfbGVhZgZyZW1vdmUUcmVtb3ZlX2xlYWZfYnlfaW5kZXgLcmlnaHRfY2hpbGQPcmlnaHRfbW9zdF9sZWFmBHJvb3QEc2l6ZQV0YWJsZQp0eF9jb250ZXh0DHVwZGF0ZV9jaGlsZAV2YWx1ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAMIBgAAAAAAAAADCAcAAAAAAAAAAwgIAAAAAAAAAAMICQAAAAAAAAADCAAAAAAAAACAAwj//////////wMI/////////38AAgMXAy4JACMDAQIEHAMZAycDIwMCAgcpAxQLAwIDCAEYCwMCAwsAAQkAHgMdAyADIgMCCgAKAAMAAA0LBwkKADgACwA4AQcJBwkGAAAAAAAAAAAGAAAAAAAAAAA5AAIBAwAADQQLADcAOAICAgMAAA0ECwA3ADgDAgMDAAANFQoAOAQgBAUFCQsAAQcEJwoANwAKADcBFDgFNwIUCwA3ARQCBAMAAA0VCgA4BCAEBQUJCwABBwQnCgA3AAoANwMUOAU3AhQLADcDFAIFAQAAGE4KAAsBOAYMAwEKAwcJIgQKBQ4LAAEHBCcHCgoDFwwFCgA3AAsDOAU3BBQMBAoEBwkiBCQFHgoACgQLBTgHDAIFJgkMAgsCBDILBAwFCgA3BQoFOAgQBhQMBAUZCgQHCSEEOwsAAQYAAAAAAAAAAAcJAgcKCgAKADcFCwQ4CBAHFDgJFwwDCwA3AAoDOAU3AhQLAwIGAwAAGE8KAAsBOAYMAwEKAwcJIgQKBQ4LAAEHBCcHCgoDFwwFCgA3AAsDOAU3BBQMBAoEBwkiBCUFHgoACgQLBTgHIAwCBScJDAILAgQzCwQMBQoANwUKBTgIEAYUDAQFGQoEBwkhBDwLAAEGAAAAAAAAAAAHCQIHCgoACgA3BQsEOAgQCBQ4ChcMAwsANwAKAzgFNwIUCwMCBwAAAAMTCwEMAgoCBwkjBA8FBwoANwULAjgIEAcUDAIFAgsAAQsCAggAAAADEwsBDAIKAgcJIwQPBQcKADcFCwI4CBAIFAwCBQILAAELAgIJAwAAGfcBCgELAgcJOQEMDwoANwYUDBAKADcGFAYBAAAAAAAAABYKADYGFQoQBwsGAQAAAAAAAAAXIwQYBRwLAAEHAScKADYAChALDzgLCgAKAQwDLgsDOAwMBwoHBwkhBEUKEAYAAAAAAAAAACEEMQU1CwABBwInBwoKEBcKADYHFQoQCgA2ARULEAsANgMVBgAAAAAAAAAAAgoANwALBzgFNwIUDAYKBgoBIgRRBVULAAEHAycxQAsGCgEdNREVMUAXFwwIBgEAAAAAAAAACwgxARcvDBEKEQcJBwkHCRIBDAwKADcIFAwNCgA3CBQGAQAAAAAAAAAWCgA2CBUKADYFCg0LDDgNCgA3BxQMEgcJDA4KEgcJIwSpAQWHAQoANwUKEjgIDAkKEQoJEAwUJASVAQsJAQWpAQsSDA4KAQoJEAwUHAYAAAAAAAAAACEEpAELCRAHFAwSBagBCwkQCBQMEgWCAQoOBwkhBLIBCg0KADYHFQXBAQoACg4KEgwFDAQuCwQLBTgHDAoKAAsOCg0LCjgOCxEKARwGAAAAAAAAAAAhDAsKAAoNBwoKEBcKCzgOCgALDQsSCwsgOA4KADcACgA3ARQ4BTcCFAoBJATjAQoQCgA2ARUKADcACgA3AxQ4BTcCFAsBIwTzAQoQCwA2AxUF9QELAAELEAIKAwAAAxsKADgEBAgLAAEJBwkCCgAKATgMDAILADcACgI4BTcCFAsBIgQYCQcJAggLAgILAwAAAxIKADgEBAcLAAEGAAAAAAAAAAACCgALATgMDAILADcACwI4BTcCFAIMAwAAG6sBCgA3AAoBOAU3AhQMDAoANwEUCgEhBBkKAAoMDAQuCwQ4DwwJAQsJCgA2ARUKADcDFAoBIQQrCgALDAwFLgsFOBAMCgELCgoANgMVCgA2AAoBOBE6AQwPDBEBCgAuOBIGAAAAAAAAAAAhBE4HCQoANgcVBwkKADYBFQcJCgA2AxUGAAAAAAAAAAAKADYIFQYAAAAAAAAAAAsANgYVBakBCg8HCSIEUwVXCwABBwYnCgA3BQoPOAgMDgoOEAYUDA0KAAoPBwoLARcMBwwGLgsGCwc4BwRxCw4QCBQMCAV1Cw4QBxQMCAsIDBAKDQcJIQSVAQoQBwkjBIcBBwkKADYFChA4Ew8GFQWQAQcJCgA2AAcKChAXOBQ2BBULEAoANgcVBaQBCgAKDQoPDAMMAi4LAgsDOAcMCwoACw0LEAsLOA4LADYFCw84FQELEQINAwAADQYLADYACwE4FDYJAg4DAAANBgsANwALATgFNwkCDwMAAAMOCgALATgGDAIEBgUKCwABBwQnCwALAjgWAhADAAAfDgsAOgABAQEBDAIMAQELATgXCwI4GAIRAwAAHxcOADcAOAIGAAAAAAAAAAAhBAcFCQYAAAAAAAAAACcLADoAAQEBAQwCDAEBCwI4GQsBOBoCEgAAACAuCgA3BxQMAwoDBwkhBAwLAAEHCQIKAwcJIwQoBREKADcFCwM4CAwCCgEKAhAMFBwGAAAAAAAAAAAhBCMLAhAHFAwDBScLAhAIFAwDBQwLAAEHCgsDFwITAAAADTcKAQcJIgQFBQkLAAEHBycLAwQTCgIKADYFCgE4Ew8HFQUaCgIKADYFCgE4Ew8IFQoCBwkiBDQKAgcJJAQsCwELADYABwoLAhc4FDYEFQUzCwELADYFCwI4Ew8GFQU2CwABAhQAAAANCQsANwULATgIEAcUCwIhAhUAAAAhawoAMgAAAAAAAAAAAAAAAAAAAAAhBAcxgAwBBWkxAAwCCgAyAAAAAAAAAAD//////////xwyAAAAAAAAAAAAAAAAAAAAACEEFwsAMUAvDAALAjFAFgwCCgAyAAAAAAAAAAAAAAAA/////xwyAAAAAAAAAAAAAAAAAAAAACEEJQsAMSAvDAALAjEgFgwCCgAyAAAAAAAAAAAAAAAAAAD//xwyAAAAAAAAAAAAAAAAAAAAACEEMwsAMRAvDAALAjEQFgwCCgAyAAAAAAAAAAAAAAAAAAAA/xwyAAAAAAAAAAAAAAAAAAAAACEEQQsAMQgvDAALAjEIFgwCCgAyAAAAAAAAAAAAAAAAAAAA8BwyAAAAAAAAAAAAAAAAAAAAACEETwsAMQQvDAALAjEEFgwCCgAyAAAAAAAAAAAAAAAAAAAAwBwyAAAAAAAAAAAAAAAAAAAAACEEXQsAMQIvDAALAjECFgwCCwAyAAAAAAAAAAAAAAAAAAAAgBwyAAAAAAAAAAAAAAAAAAAAACEEZwsCMQEWDAILAgwBCwECAgICAwAAAgQAAgIBAQMBAQECAgYCAAIFAQAAAQAKAQoCCgMKBAoFCgkKCgoLCg0KAAsACWN1c3RvZGlhbtsMoRzrCwYAAAAOAQAMAgwwAzykAQTgAR4F/gH2AQf0A8AECLQIQAb0CAoK/ggmC6QJBAyoCeACDYgMCA6QDAYPlgwCABcBDwEVASMBJQEmAAAEAQABAAEMAAAEDAEAAQECBAEAAQIDDAEAAQMFBwADCAQABAYMAgcBBAEFBwIAACEAAQAACgIDAQAAIgAEAQAAKgUGAQAAKwUGAQAAHAcIAQAAGAkKAQAAHQsIAQAAGQwKAQAAHwkIAQAAKAwIAQAACQINAQAADAINAQAAEw4PAQAAEQIQAQABHhoNAQABJB0KAQABKRcNAQABLAgKAQACGhkGAQADIgARAAMnGxwABA0fCAIHBAQQFRYCBwQEEiAhAgcEBBYVHgIHBAQiABgCBwQXFBETGhQGExMTDRMPExATBxMIEwUTGRQSExYUGBQBBwgIAQgBAgYLAgEJAAgFAgMDAQsCAQkABAcLAgEJAAMGCAEHCAgBCwQBCQADBwsCAQkACAULAwEJAAADBwsCAQkABggBAwELAwEJAAMHCwIBCQAGCAELAwEJAAMHCwIBCQAIBQMBAwIHCwIBCQAIBQEHCwABCQABBgsAAQkAAQgGAwYLAAEJAAMDAQkAAggFCwABCQACBgsHAgkACQEJAAEGCQEBBgsDAQkAAQsHAgkACQECCwMBCQAHCAgCBwsDAQkACwMBCQABBggGAQgFAgcLAwEJAAMBAQMHCwcCCQAJAQkACQECBwsHAgkACQEJAAEHCQEHQWNjb3VudApBY2NvdW50Q2FwB0JhbGFuY2UEQ29pbglDdXN0b2RpYW4CSUQFVGFibGUJVHhDb250ZXh0A1VJRBlhY2NvdW50X2F2YWlsYWJsZV9iYWxhbmNlD2FjY291bnRfYmFsYW5jZRBhY2NvdW50X2JhbGFuY2VzFmFjY291bnRfbG9ja2VkX2JhbGFuY2UDYWRkEWF2YWlsYWJsZV9iYWxhbmNlB2JhbGFuY2UGYm9ycm93FmJvcnJvd19hY2NvdW50X2JhbGFuY2UKYm9ycm93X211dBpib3Jyb3dfbXV0X2FjY291bnRfYmFsYW5jZQRjbG9iBGNvaW4IY29udGFpbnMJY3VzdG9kaWFuH2RlY3JlYXNlX3VzZXJfYXZhaWxhYmxlX2JhbGFuY2UcZGVjcmVhc2VfdXNlcl9sb2NrZWRfYmFsYW5jZQxmcm9tX2JhbGFuY2UCaWQfaW5jcmVhc2VfdXNlcl9hdmFpbGFibGVfYmFsYW5jZRxpbmNyZWFzZV91c2VyX2xvY2tlZF9iYWxhbmNlBGpvaW4MbG9ja19iYWxhbmNlDmxvY2tlZF9iYWxhbmNlEG1pbnRfYWNjb3VudF9jYXADbmV3Bm9iamVjdAVzcGxpdAV0YWJsZQp0eF9jb250ZXh0DHVpZF90b19pbm5lcg51bmxvY2tfYmFsYW5jZQV2YWx1ZRN3aXRoZHJhd19iYXNlX2Fzc2V0FHdpdGhkcmF3X3F1b3RlX2Fzc2V0BHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgBAAAAAAAAAAACAg4LAwEJACALAwEJAAECARsIBgICAhsIBgsLBwIIBQsAAQkAAhMAEwABAAAIBAsAERQSAQIBAwAAEhALADcACwE4AAwCCgI3ATgBDAMLAjcCOAEMBAsDCwQCAgMAAAgGCgARFAsAOAI5AAIDAwAACAcLAAsCCwE4AwsDOAQCBAMAAAgHCwALAgsBOAMLAzgEAgUDAAAICAsACwE4BTYBCwI4BgECBgMAAAgJCwALARADERU4BTYBCwI4BwIHAwAACAoLAAsBEAMRFTgFNgILAjgGAQIIAwAACAcLAAsBOAU2AgsCOAcCCQMAAAoKCgAKAQsCOAMMAwsACwELAzgIAgoDAAAKCgoACgELAjgJDAMLAAsBCwM4CgILAwAACAcLADcACwE4ADcBOAECDAMAAAgHCwA3AAsBOAA3AjgBAg0AAAAIEgoANwAKATgLIAQNCgA2AAoBOAw4DDkBOA0LADYACwE4DgIOAAAACA8KADcACgE4CwQGBQoLAAEHACcLADcACwE4AAICAQAAAAEBAAATARMCEwAUAA0JY3VzdG9kaWFuB0FjY291bnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QljdXN0b2RpYW4KQWNjb3VudENhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pCWN1c3RvZGlhbglDdXN0b2RpYW4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6Qdjcml0Yml0BExlYWYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6Qdjcml0Yml0DEludGVybmFsTm9kZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pB2NyaXRiaXQLQ3JpdGJpdFRyZWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QRjbG9iC1Bvb2xDcmVhdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukEY2xvYgtPcmRlclBsYWNlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pBGNsb2INT3JkZXJDYW5jZWxlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pBGNsb2ILT3JkZXJGaWxsZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QRjbG9iBU9yZGVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukEY2xvYglUaWNrTGV2ZWwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QRjbG9iBFBvb2wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQAAAAAAAAADIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9jYXAfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAABAQAAAAAAAABAAHqbsn8OpKKfQ7vwEvZfunbBp0u71UctBl6cV5veQ1PuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjADuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjCA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAEBAQAAAAAAAAAoBwnRr+4OFRx+9xpBP6AJklpKh6LPY0JTdxSt8dX+e9UAAENP15RqAAB7gyC3+hQw3PBZTqueIMXSiSbGrSFnT7J7B9e7Z4tH0SA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMc3Rha2luZ19wb29sFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQAAAQAAAAAAAAA4CYMkAqiMkEcvpmNpYmiU/Vy85L6Wh5xsOEIo9GSykq8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEPbgCrvFItofhUCCKD+1RwzNdqLhu4M4f9rV4nsUQ2AgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKA/UP31tlxtnGYat9GhBzyjbn1CvsLg7ushPyh4H2ov+AABDT9eUagAASbqjLqQLRaVJBEqkO9WZIS+2HRyXkMY0r1OcHCjH2dsgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKCEZKPioHQ6EK4IiUcJ2Izh65HrwDnMxA28tLtjn6Q3OAABDT9eUagAAe4Mgt/oUMNzwWU6rniDF0okmxq0hZ0+yewfXu2eLR9EgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKDBKGP+E0kg67W3UBbJ3Xbv4tLxmLUk+U9UnJuN6xnXiAABDT9eUagAASbqjLqQLRaVJBEqkO9WZIS+2HRyXkMY0r1OcHCjH2dsgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKDfCnsKTwyVNanGnsZeJxyKcxqNXAtlEddwihLxQ7k57AABDT9eUagAADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCAgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX2NhcB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwAAEBAAAAAAAAAEBCsDx7L8K+gWjtx/EP+rtuYWR86pOMKzz58OWFnTKsJ2swbQww+L6NZtj1wibPCFcCRPBJ/Kd+mybJY5X5JRsSAGswbQww+L6NZtj1wibPCFcCRPBJ/Kd+mybJY5X5JRsSIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAAChKNeYcaXF/YHYE1Sj7GRXDsEV6B3b2bEkuwUaRhuDWfQAAQ0/XlGoAALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYvIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAAChM4jLNAglbpQnWaZZQ8RHQOjPXmJ3l2xJoKm+6KBUrrgAAQ0/XlGoAAEm6oy6kC0WlSQRKpDvVmSEvth0cl5DGNK9TnBwox9nbIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAgABAAAAAAAAAFBRKdl9Yt19UpGKCsmRSlDWhiQ3V8hUvA+NClz44p+gkeI0jXDjbx6aK976Je9kNGE85R4sU4I2M+QXJn6zBfXvAAAAAAAAAAAAAILf5A1HAABrMG0MMPi+jWbY9cImzwhXAkTwSfynfpsmyWOV+SUbEiA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZvYmplY3QCSUQABAABAAAAAAAAAGBgfIsUNYTWCBwV6nvXQAxIphrbHJ7mDz0qIu/h5JMlELRlf1hkJmZjOWn2aj29My5Fn0dzIw0TLJ3cFPEot9D47jVL4xqhzJpt7/k0yHfLDJvMAQYVZAeoSdHGasv23IwBH5X7PezikvbL9aJSs1MhPPUujX8SkkZ3tOp4HN/HnjogOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKGG1E0/OoMAWydFtrH2zwQEnlSCY03U50NzifCTRD7hvAABDT9eUagAAtqGXTARPET/4NEhSJPrRIEHWQXOsaeobUpmOqmJRVi8gOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAICBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXITU3VpU3lzdGVtU3RhdGVJbm5lcgAAAQAAAAAAAACfGmryorfKYL92F0rf0+nElX+Ok3dZYDGC+bRsf2xfGcbSAQAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAQAAAAAAAAAAAAh+kzccAQQdlqGWc4hYr9v2AUTi0cWqjRDVpFw3WhCtgvkiAFE0GmCNz/bRVQQKZW9IGbExEbUsV0aoa6cvOV+6/i7DhH0egUDmJKdR/fa18gULxyBc+dMABMkLDHQK/9Mmzmc8wrI6LSTVPir+sobfxmj9QGAInW0rF7eZ3Tb5DTMuVKejONQgXw9Cyz+yDdV3cDOIMglk+TUdmXMTwEoDIkcGDSFLLnEgNzcStuIbnPffsBHiunWHMc4LcUlzICVo1U95+8yxd0kwiyzWtDylvqPLC+t6rUZeJFE6XLu39wLim2VBbz6NAb3a9tiL09BgKVbugWjBAwqkC3ZhbGlkYXRvci0xAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zMzM1NS9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC80NjMzNRgvaXA0LzEyNy4wLjAuMS91ZHAvNDIwMzkYL2lwNC8xMjcuMC4wLjEvdWRwLzM5ODU5AAAAAAAAAAAHILRUHKflqCQ6XlUQIcvq3QMXSSZwaCnEEUgkkENUsQAAAAAAAAAAxAkAAAAAAACTUVVPz8b4Xk1FkdnT000IXQ4QZNveyI+mLkBEzvWKyugDAAAAAAAAKy99JiJBKTD5NRW3IWxgJIMbYO1PHb7BK6zx6IKb7MgBAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAk8OcOHHTZYqWVqUUx83pyU4uLCAM8PPRW5Mg+VhHpX4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyX/uAqGGEFaDV6mBiFQEslfqFrHjwiD4Ip+CIUUS9kAAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAAEcs98D4eYltE4bUFz9hTqzOoO+B21sTPFiPFEzAULNyAAAAAAAAAADuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjGCZ8l72H4AyuRRjZGCYLFzG8TTvHdrnZlfyy/7B6/yNCXN0CA32/PDcuLxLDY4K9dgOu/8rTFmfVPQtYxLfwxQnYHjBzDR+u77FGYviWFE/OGuTDQLCdJqAPiMwlV69GhAgzmDjB34Co2g0Nq9FDzpFEbTECxWJVmN8r5zPETkefhAgEWzsBHlYiAE3N5D0DGMCQVlkWIKcTt9IlzeiMQ0CFtwwi4uTNREZbHVnSkLgGmQBE40j2XtrTtF/mCMsCsMrnHONz/ga9tRpQKesAW2h857NC3ZhbGlkYXRvci0wAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zNjQ1OS9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC80NDA2MRgvaXA0LzEyNy4wLjAuMS91ZHAvMzY3NDUYL2lwNC8xMjcuMC4wLjEvdWRwLzM5NDEzAAAAAAAAAAAqj9QggOfSzl4V+GoGupp0zLLjFK7Ai/kU14Z0pcplwgAAAAAAAAAAxAkAAAAAAAAAepuyfw6kop9Du/AS9l+6dsGnS7vVRy0GXpxXm95DU+gDAAAAAAAAtGV/WGQmZmM5afZqPb0zLkWfR3MjDRMsndwU8Si30PgBAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAdk7bK8RROD8dpsPXdTNoXuGWH148/rlAHPlcYlgMuhsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOALCrjh1OlDO9wp3K37FsmQUyK0Z+1veXMy6WoD6PPpAAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAAMCoc8pdZWPKGUV6q+J5JXMc4SlHoBErQiqd4mV0fA7zAAAAAAAAAACRzKvCogqNa1yKYBCVcquLQ2r6tbMDzoDk8W3A3kTxCWCt3u+U2JjIjkDb3v+RxfEF+c8sdH+28rw37APWyR7bLhpXjPVEvosJMeJfJD1ZsMMNmKFs47odbPHX9QQmmS6wrbMTSwVb6BQNLbXyX7ANg/jkIivwH9ask6H/TXnaWPIgbZCVEwsVNsDJIY6p/rDzZoWm+gs7HmfSVsxPs0CkjWkg4aJsYZ6zZso+y9AJsSdyVwZpvS5xBIkFkHq/P1vVicAwg54KGo44DGyw4IzRjcWLzbg6Jk6yWiOvJMf7BMOaTNaad3ggvrve/e4nm6wmN8RBC3ZhbGlkYXRvci0yAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zNDYzMy9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC8zMjk2NRgvaXA0LzEyNy4wLjAuMS91ZHAvMzU0NTcYL2lwNC8xMjcuMC4wLjEvdWRwLzM4Nzc3AAAAAAAAAABTNhzYGW9m5KkSFn9ArSMiPdKVXpJY3m2tPt4e9IrJagAAAAAAAAAAxAkAAAAAAAB4lQ80jeOmoKV/UC9hBPicN/10aUq5MV0cEovDw1a5ZOgDAAAAAAAA6acBh9L1XSJ3yoBV6dqFMrxVeE0xtplrp4+c1CltCD4BAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAsKJKXbPSW1XP7jTBDgMK2GrtaGaWY4MGkj4hEakxfIQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGgWz9PGeUN9QEyThBHsL0qqjU3+ySOilTRettQOhqr+AAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAANQQ3CSl/J897uufZyU7yE/TheAJXn18ZUcAhNz0IoB9AAAAAAAAAABrMG0MMPi+jWbY9cImzwhXAkTwSfynfpsmyWOV+SUbEmCz/V77XIckA6StE/EZlRNgbSM1SoRSSa6hV1ZMI/88FcbJ5lK3LXQOjKy5PLzAaGsOwMwMHHYL+0K0NlGfxagFS3ZTOpep8jmH0JfvlrHyUmuyBz+hCncZlBdyNH7ydPQgspFb94eEWlXCThj9wWKldesC0juuP55WbXxR68/rSkIg8kw7zFaMQz00lCDtKETmq8+h3WPHxOET+m/+d8OLN5cwjH1jRasTAwXh522c5CGYCtEP3OL4+3AftEv/V5VTo84aM98Vcq7RvxQRQNNvdRjFC3ZhbGlkYXRvci0zAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zMzk1My9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC8zOTg4ORgvaXA0LzEyNy4wLjAuMS91ZHAvMzgxNzUYL2lwNC8xMjcuMC4wLjEvdWRwLzM0NjU1AAAAAAAAAAB5Bga3JMoC4IzRoFv5/VtYTjXap+MAb9AY/b0XUvqcEgAAAAAAAAAAxAkAAAAAAABCsDx7L8K+gWjtx/EP+rtuYWR86pOMKzz58OWFnTKsJ+gDAAAAAAAA4jSNcONvHpor3vol72Q0YTzlHixTgjYz5BcmfrMF9e8BAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAEPbgCrvFItofhUCCKD+1RwzNdqLhu4M4f9rV4nsUQ2ABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA960Qi0S0U6BDq5/IpdoN9qCAL0Mtadv9qsbqs0kX43AAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAALXy8lsznanogWAJQdi8BJRveAbXZAU0khL0/RuSvMUlAAAAAAAAAADyDLlENgEFhcdiENKB4e7ewpnQ11c5Rq+IXbCiPkqX5wAAAAAAAAAAAB+V+z3s4pL2y/WiUrNTITz1Lo1/EpJGd7TqeBzfx546BAAAAAAAAAD05hHSH05rAHQinJqI2qlgmwDYW0Ar1ZUlKvAb1YO3/AAAAAAAAAAAme3BiKhIlx5YejQ6LP0fUAchBVxU5UQnLbIE5YzOhjoAAAAAAAAAAAD8MKYtNUf67vuKdE6P5oQ1FIAoRKku2yiTHCg7VYAmMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcJgUAAAAAAAAAAAAAAACWAAAAAAAAAAAAQ0/XlGoAAACC3+QNRwAAgKGna0o1AAcAAAAAAAAAHYs50dCPQ6ybhPyI0uSJq3qb5mDjI+lgzdtX3nxAfZ4AAAAAAAAAAOgDAAAAAAAAAAAAVU5qYkJ/AAAAAAAAAAAAgMakfo0DAB4AAAAAAAAAECckK9UFd0RjYpGX8B3DEoyR+9yoxKKlGpdtNOBIobrHiQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyjYfxIcBAAAV2oCN7dMGWG9VQgN8pL4hchVVXQwtTLf/u3XRt82O5gAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdAJJRAAEAAEAAAAAAAAAYG9K5N0GAbBI9KRfwZM4xDkmJZgZRdpwBFqw+I5iZSfk6acBh9L1XSJ3yoBV6dqFMrxVeE0xtplrp4+c1CltCD6RzKvCogqNa1yKYBCVcquLQ2r6tbMDzoDk8W3A3kTxCQEflfs97OKS9sv1olKzUyE89S6NfxKSRne06ngc38eeOiA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAEBAQAAAAAAAAAocrHwMFQ2RyIvH5dN0jctJwrdKLCKrxwwE4+I55HSuHcAAENP15RqAADthnMV4/fIOugubVhYtqbMV8KR/YT3UJZG68gWIWnPliA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3JfY2FwH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAAAQEAAAAAAAAAQHiVDzSN46agpX9QL2EE+Jw3/XRpSrkxXRwSi8PDVrlkkcyrwqIKjWtcimAQlXKri0Nq+rWzA86A5PFtwN5E8QkAkcyrwqIKjWtcimAQlXKri0Nq+rWzA86A5PFtwN5E8QkgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKH/c+eGxtFPbKUcOgriLDorVsn68q/MlV4ZztI48RHUyAABDT9eUagAADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCAgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAICBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbBVQb29sVG9rZW5FeGNoYW5nZVJhdGUAAAEAAAAAAAAAOIPPqx/ASzp7pQUJomHnoaaptjY6UfDVGIjuNg5HiV5zAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXZO2yvEUTg/HabD13UzaF7hlh9ePP65QBz5XGJYDLobIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAgABAAAAAAAAAFCD1k5PxPNdgUPU8A5P0F0T6TLQG53sFFWq/UuWbxuQA+mnAYfS9V0id8qAVenahTK8VXhNMbaZa6ePnNQpbQg+AAAAAAAAAAAAAILf5A1HAACRzKvCogqNa1yKYBCVcquLQ2r6tbMDzoDk8W3A3kTxCSA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAIAAQAAAAAAAABQjrJWUBUCi6DrGMVCiRBDeF67hge4JeBmdiz2cb6EV+y0ZX9YZCZmYzlp9mo9vTMuRZ9HcyMNEyyd3BTxKLfQ+AAAAAAAAAAAAACC3+QNRwAA7jVL4xqhzJpt7/k0yHfLDJvMAQYVZAeoSdHGasv23IwgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX2NhcB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwAAEBAAAAAAAAAECTUVVPz8b4Xk1FkdnT000IXQ4QZNveyI+mLkBEzvWKyh2WoZZziFiv2/YBROLRxaqNENWkXDdaEK2C+SIAUTQaAB2WoZZziFiv2/YBROLRxaqNENWkXDdaEK2C+SIAUTQaIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACiUHTR/XH5fbwyHvE1TeYoyKoXPuds/c+6AmN2EQAvwSQAAQ0/XlGoAALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYvIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACif+8ou5m6v5tWQLynLCoTbMT3JtUpEGKNoezkhptm7AgAAQ0/XlGoAAA0PBMs887515Y/9UZvSiCITFTbuMmwAfBPaR6cAnhQgIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACijAXq/p9dM2BQpEwtYWn+/GEXo4VuA1dicvmWo6FO/RQAAQ0/XlGoAAEm6oy6kC0WlSQRKpDvVmSEvth0cl5DGNK9TnBwox9nbIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBGNvaW4MQ29pbk1ldGFkYXRhAQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNzdWkDU1VJAAEBAAAAAAAAACulo9wBjqkC8AGuUEQlGdMOdmYxqXFPMJtJfaj6xSSanQkDU3VpA1NVSQAAAyA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAEBAQAAAAAAAAAorVKLQpjShTyMFJa6S1Z2NRfOixJQLdmPsuIKA9yHDJsAAENP15RqAAB7gyC3+hQw3PBZTqueIMXSiSbGrSFnT7J7B9e7Z4tH0SA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAEBAQAAAAAAAAAotAG9KMfDh5nTAb7yCkmY70wH7b0VZdSH/6sTv7qGlGMAAENP15RqAABJuqMupAtFpUkESqQ71ZkhL7YdHJeQxjSvU5wcKMfZ2yA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZvYmplY3QCSUQABAABAAAAAAAAAGC1MJTIzFY4NvYcAOq40vVWuAJG9eQp/7hprGpOG1wz1+I0jXDjbx6aK976Je9kNGE85R4sU4I2M+QXJn6zBfXvazBtDDD4vo1m2PXCJs8IVwJE8En8p36bJsljlfklGxIBH5X7PezikvbL9aJSs1MhPPUujX8SkkZ3tOp4HN/HnjogOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKMAcdWgA5ISlSU5WNhKQU2PYbLqwpkPJ9vbm32GoCPOSAABDT9eUagAADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCAgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGb2JqZWN0AklEAAQAAQAAAAAAAABgx/bBVyy7AWKMeFuv5r3y8Y6C+mUC1uqBMPMVQqxQXe0rL30mIkEpMPk1FbchbGAkgxtg7U8dvsErrPHogpvsyB2WoZZziFiv2/YBROLRxaqNENWkXDdaEK2C+SIAUTQaAR+V+z3s4pL2y/WiUrNTITz1Lo1/EpJGd7TqeBzfx546IDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACjNTjbpEa5n6Z6lsDppQZByGyh6FJsoBAfGQESiqtLaugAAQ0/XlGoAAO2GcxXj98g66C5tWFi2psxXwpH9hPdQlkbryBYhac+WIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACjSkCP8hjC+flK3MDTgw/8583YlaxHBSMD5dYyJhEQxiwAAQ0/XlGoAAO2GcxXj98g66C5tWFi2psxXwpH9hPdQlkbryBYhac+WIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACjVPbaUooNGZN0s/0P/AHo0OTiax02I9dl1oSwx/CDIyQAAQ0/XlGoAALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYvIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wVUG9vbFRva2VuRXhjaGFuZ2VSYXRlAAABAAAAAAAAADjWGyj7IpNTLEYSK13Xfkml+I1vcz5xoMsRrGb+jlm/8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGwokpds9JbVc/uNMEOAwrYau1oZpZjgwaSPiERqTF8hCA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAEBAQAAAAAAAAAo2xoN5HUtUP2UcTpF7ReW+p2ZDE5RHLUhXoJ3TJbmnK0AAENP15RqAAANDwTLPPO+deWP/VGb0ogiExU27jJsAHwT2kenAJ4UICA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMc3Rha2luZ19wb29sFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQAAAQAAAAAAAAA42zYCSgCTK1+lM8dUMETPEjhVdAMjRG04cBtiwqMow3kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABk8OcOHHTZYqWVqUUx83pyU4uLCAM8PPRW5Mg+VhHpX4gOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKN+Z5K7+QFhNp0EMDPe0fkc5ciqr9vp3MANEd6hvuWJuAABDT9eUagAAe4Mgt/oUMNzwWU6rniDF0okmxq0hZ0+yewfXu2eLR9EgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKOD93T7kZHagd2uRlkNQ2O4HJ81FE3BNnUZz8/xN+FA8AABDT9eUagAAtqGXTARPET/4NEhSJPrRIEHWQXOsaeobUpmOqmJRVi8gOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKOzttkGbkRDdqk0UX0PTgzZL1rWejAZw+GBSDSDqBpgvAABDT9eUagAA7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5YgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKO6xodBEIKA4CT/RgTexRuZLKamQ425++rBXsm6Bn8lSAABDT9eUagAA7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5YgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAACAAEAAAAAAAAAUPdmHL9ncVy6VvG8NKg7pM/GGv4DwqS/js+lKWXXCyUZKy99JiJBKTD5NRW3IWxgJIMbYO1PHb7BK6zx6IKb7MgAAAAAAAAAAAAAgt/kDUcAAB2WoZZziFiv2/YBROLRxaqNENWkXDdaEK2C+SIAUTQaIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACj53Ug1HQlNHdXS1lnq6BcObvZ2YB+/ZUyZK2fLrR8eCAAAQ0/XlGoAAHuDILf6FDDc8FlOq54gxdKJJsatIWdPsnsH17tni0fRIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAA= diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/sui.keystore b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/sui.keystore new file mode 100644 index 0000000000..47355b9391 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/sui.keystore @@ -0,0 +1,7 @@ +[ + "AB522qKKEsXMTFRD2SG3Het/02S/ZBOugmcH3R1CDG6l", + "AOmPq9B16F3W3ijO/4s9hI6v8LdiYCawKAW31PKpg4Qp", + "AOLhc0ryVWnD5LmqH3kCHruBpVV+68EWjEGu2eC9gndK", + "AKCo1FyhQ0zUpnoZLmGJJ+8LttTrt56W87Ho4vBF+R+8", + "AGA20wtGcwbcNAG4nwapbQ5wIuXwkYQEWFUoSVAxctHb" +] \ No newline at end of file diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/validator-config-0.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/validator-config-0.yaml new file mode 100644 index 0000000000..27d370a59d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/validator-config-0.yaml @@ -0,0 +1,81 @@ +--- +protocol-key-pair: + value: VTDx4HjVmRBqdqBWg2zN+zcFE20io3CrBchGy/iV1lo= +worker-key-pair: + value: ABlC9PMmIQHjxila3AEOXDxwCSuodcvJh2Q5O5HIB00K +account-key-pair: + value: AIV4Ng6OYQf6irjVCZly5X7dSpdFpwoWtdAx9u4PANRl +network-key-pair: + value: AOqJl2rHMnroe26vjkkIuWGBD/y6HzQG6MK5bC9njF0s +db-path: sui_config/authorities_db/99f25ef61f80 +network-address: /ip4/127.0.0.1/tcp/36459/http +json-rpc-address: "127.0.0.1:38133" +metrics-address: "127.0.0.1:44135" +admin-interface-port: 33917 +consensus-config: + address: /ip4/127.0.0.1/tcp/41459/http + db-path: sui_config/consensus_db/99f25ef61f80 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/44689/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/33219/http + network_admin_server: + primary_network_admin_server_port: 33945 + worker_network_admin_server_base_port: 38081 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:44061" + external-address: /ip4/127.0.0.1/udp/44061 +genesis: + genesis-file-location: sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/validator-config-1.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/validator-config-1.yaml new file mode 100644 index 0000000000..31920d77c1 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/validator-config-1.yaml @@ -0,0 +1,81 @@ +--- +protocol-key-pair: + value: avYcyVgYMXTyaUYh9IRwLK0gSzl7YF6ZQDAbrS1Bhvo= +worker-key-pair: + value: AGsxCVxeIZ6fscvGECzV93Hi4JkqM4zMYEA8wBGfXQrz +account-key-pair: + value: AF9cOMxTRAUTOws2M8W5slHf41HITA+M3nqXHT6nlH6S +network-key-pair: + value: ALH/8qz2YlwAuxY/hOvuXiglYq0e4LLU1/lyf5uKgPY8 +db-path: sui_config/authorities_db/8dcff6d15504 +network-address: /ip4/127.0.0.1/tcp/33355/http +json-rpc-address: "127.0.0.1:39573" +metrics-address: "127.0.0.1:45851" +admin-interface-port: 35739 +consensus-config: + address: /ip4/127.0.0.1/tcp/42959/http + db-path: sui_config/consensus_db/8dcff6d15504 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/37001/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/39831/http + network_admin_server: + primary_network_admin_server_port: 39853 + worker_network_admin_server_base_port: 36429 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:46335" + external-address: /ip4/127.0.0.1/udp/46335 +genesis: + genesis-file-location: sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/validator-config-2.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/validator-config-2.yaml new file mode 100644 index 0000000000..caa5501a66 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/validator-config-2.yaml @@ -0,0 +1,81 @@ +--- +protocol-key-pair: + value: OXnx3yM1C/ppgnDMx/o1d49fJs7E05kq11mXNae/O+I= +worker-key-pair: + value: AHXs8DP7EccyxtxAGq/m33LgvOApXs4JStH3PLAe9vGw +account-key-pair: + value: AC8vF9E3QYf0aTyBZWlSzJJXETvV5vYkOtEJl+DWQMlk +network-key-pair: + value: AOapcKU6mW5SopFM6eBSiXgbuPJTz11CiEqM+SJGIEOF +db-path: sui_config/authorities_db/addeef94d898 +network-address: /ip4/127.0.0.1/tcp/34633/http +json-rpc-address: "127.0.0.1:38025" +metrics-address: "127.0.0.1:43451" +admin-interface-port: 36793 +consensus-config: + address: /ip4/127.0.0.1/tcp/40307/http + db-path: sui_config/consensus_db/addeef94d898 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/37445/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/43943/http + network_admin_server: + primary_network_admin_server_port: 39611 + worker_network_admin_server_base_port: 38377 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:32965" + external-address: /ip4/127.0.0.1/udp/32965 +genesis: + genesis-file-location: sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/validator-config-3.yaml b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/validator-config-3.yaml new file mode 100644 index 0000000000..0d44fa2483 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/sui_config/validator-config-3.yaml @@ -0,0 +1,81 @@ +--- +protocol-key-pair: + value: CyNkjqNVr3HrHTH7f/NLs7u5lUHJzuPAw0PqMTD2y2s= +worker-key-pair: + value: AHd6qvbBv7bTCGGoD1TUR5dOGnwOnYvhHV9ryCUp7rmZ +account-key-pair: + value: ALSCvWwsVryGIwq+n4f9bIPCRqsooGodE/vDaVCSLfjE +network-key-pair: + value: APFCK1pRVxn9PDt+KzWx52+EY5nzaZZU2GF9RZoQY58Y +db-path: sui_config/authorities_db/b3fd5efb5c87 +network-address: /ip4/127.0.0.1/tcp/33953/http +json-rpc-address: "127.0.0.1:35625" +metrics-address: "127.0.0.1:37813" +admin-interface-port: 46405 +consensus-config: + address: /ip4/127.0.0.1/tcp/43213/http + db-path: sui_config/consensus_db/b3fd5efb5c87 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/46745/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/38817/http + network_admin_server: + primary_network_admin_server_port: 34929 + worker_network_admin_server_base_port: 37447 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:39889" + external-address: /ip4/127.0.0.1/udp/39889 +genesis: + genesis-file-location: sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/testing/tsconfig.json b/target_chains/iota/vendor/wormhole_iota_testnet/testing/tsconfig.json new file mode 100644 index 0000000000..d6a4db0856 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/testing/tsconfig.json @@ -0,0 +1,12 @@ +{ + "compilerOptions": { + "types": ["mocha", "chai"], + "typeRoots": ["./node_modules/@types"], + "lib": ["es2020"], + "module": "commonjs", + "target": "es2020", + "strict": true, + "resolveJsonModule": true, + "esModuleInterop": true + } + } diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/.gitignore b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/.gitignore new file mode 100644 index 0000000000..378eac25d3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/.gitignore @@ -0,0 +1 @@ +build diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Makefile b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Makefile new file mode 100644 index 0000000000..b1c345e0f3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Makefile @@ -0,0 +1,18 @@ +-include ../../Makefile.help + +VERSION = $(shell grep -Po "version = \"\K[^\"]*" Move.toml | sed "s/\./_/g") + +.PHONY: clean +clean: + rm -rf build + +.PHONY: check +## Build contract +check: + sui move build -d + +.PHONY: test +## Run tests +test: check + grep "public(friend) fun current_version(): V__${VERSION} {" sources/version_control.move + sui move test -t 1 diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.devnet.toml b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.devnet.toml new file mode 100644 index 0000000000..c63e72576d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.devnet.toml @@ -0,0 +1,14 @@ +[package] +name = "TokenBridge" +version = "0.2.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../wormhole" + +[addresses] +token_bridge = "_" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.lock b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.lock new file mode 100644 index 0000000000..130fedfa70 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.lock @@ -0,0 +1,39 @@ +# @generated by Move, please check-in and do not edit manually. + +[move] +version = 0 +manifest_digest = "868DAEC26B76907DDD55CB64F8F3373546E028B90763B6BD8D1544F7EB721AAD" +deps_digest = "060AD7E57DFB13104F21BE5F5C3759D03F0553FC3229247D9A7A6B45F50D03A3" + +dependencies = [ + { name = "Sui" }, +] + +dev-dependencies = [ + { name = "Wormhole" }, +] + +[[move.package]] +name = "MoveStdlib" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/move-stdlib" } + +[[move.package]] +name = "Sui" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/sui-framework" } + +dependencies = [ + { name = "MoveStdlib" }, +] + +[[move.package]] +name = "Wormhole" +source = { local = "../wormhole" } + +dependencies = [ + { name = "Sui" }, +] + +[move.toolchain-version] +compiler-version = "1.19.0" +edition = "legacy" +flavor = "sui" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.mainnet.toml b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.mainnet.toml new file mode 100644 index 0000000000..829ab68b0e --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.mainnet.toml @@ -0,0 +1,15 @@ +[package] +name = "TokenBridge" +version = "0.2.0" +published-at = "0x26efee2b51c911237888e5dc6702868abca3c7ac12c53f76ef8eba0697695e3d" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../wormhole" + +[addresses] +token_bridge = "0x26efee2b51c911237888e5dc6702868abca3c7ac12c53f76ef8eba0697695e3d" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.testnet.toml b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.testnet.toml new file mode 100644 index 0000000000..143976d3d4 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.testnet.toml @@ -0,0 +1,15 @@ +[package] +name = "TokenBridge" +version = "0.2.0" +published-at = "0x562760fc51d90d4ae1835bac3e91e0e6987d3497b06f066941d3e51f6e8d76d0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../wormhole" + +[addresses] +token_bridge = "0x562760fc51d90d4ae1835bac3e91e0e6987d3497b06f066941d3e51f6e8d76d0" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.toml b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.toml new file mode 100644 index 0000000000..ac81fbab56 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/Move.toml @@ -0,0 +1,21 @@ +[package] +name = "TokenBridge" +version = "0.2.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../wormhole" + +[addresses] +token_bridge = "_" + +[dev-dependencies.Wormhole] +local = "../wormhole" + +[dev-addresses] +wormhole = "0x100" +token_bridge = "0x200" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/attest_token.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/attest_token.move new file mode 100644 index 0000000000..16134c5c76 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/attest_token.move @@ -0,0 +1,385 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements the method `attest_token` which allows someone +/// to send asset metadata of a coin type native to Iota. Part of this process +/// is registering this asset in the `TokenRegistry`. +/// +/// NOTE: If an asset has not been attested for, it cannot be bridged using +/// `transfer_tokens` or `transfer_tokens_with_payload`. +/// +/// See `asset_meta` module for serialization and deserialization of Wormhole +/// message payload. +module token_bridge::attest_token { + use iota::coin::{CoinMetadata}; + use wormhole::publish_message::{MessageTicket}; + + use token_bridge::asset_meta::{Self}; + use token_bridge::create_wrapped::{Self}; + use token_bridge::state::{Self, State, LatestOnly}; + use token_bridge::token_registry::{Self}; + + /// Coin type belongs to a wrapped asset. + const E_WRAPPED_ASSET: u64 = 0; + /// Coin type belongs to an untrusted contract from `create_wrapped` which + /// has not completed registration. + const E_FROM_CREATE_WRAPPED: u64 = 1; + + /// `attest_token` takes `CoinMetadata` of a coin type and generates a + /// `MessageTicket` with encoded asset metadata for a foreign Token Bridge + /// contract to consume and create a wrapped asset reflecting this Iota + /// asset. Asset metadata is encoded using `AssetMeta`. + /// + /// See `token_registry` and `asset_meta` module for more info. + public fun attest_token( + token_bridge_state: &mut State, + coin_meta: &CoinMetadata, + nonce: u32 + ): MessageTicket { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // Encode Wormhole message payload. + let encoded_asset_meta = + serialize_asset_meta(&latest_only, token_bridge_state, coin_meta); + + // Prepare Wormhole message. + state::prepare_wormhole_message( + &latest_only, + token_bridge_state, + nonce, + encoded_asset_meta + ) + } + + fun serialize_asset_meta( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + coin_meta: &CoinMetadata, + ): vector { + let registry = state::borrow_token_registry(token_bridge_state); + + // Register if it is a new asset. + // + // NOTE: We don't want to abort if the asset is already registered + // because we may want to send asset metadata again after registration + // (the owner of a particular `CoinType` can change `CoinMetadata` any + // time after we register the asset). + if (token_registry::has(registry)) { + let asset_info = token_registry::verified_asset(registry); + // If this asset is already registered, there should already + // be canonical info associated with this coin type. + assert!( + !token_registry::is_wrapped(&asset_info), + E_WRAPPED_ASSET + ); + } else { + // Before we consider registering, we should not accidentally + // perform this registration that may be the `CoinMetadata` from + // `create_wrapped::prepare_registration`, which has empty fields. + assert!( + !create_wrapped::incomplete_metadata(coin_meta), + E_FROM_CREATE_WRAPPED + ); + + // Now register it. + token_registry::add_new_native( + state::borrow_mut_token_registry( + latest_only, + token_bridge_state + ), + coin_meta + ); + }; + + asset_meta::serialize(asset_meta::from_metadata(coin_meta)) + } + + #[test_only] + public fun serialize_asset_meta_test_only( + token_bridge_state: &mut State, + coin_metadata: &CoinMetadata, + ): vector { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + serialize_asset_meta(&latest_only, token_bridge_state, coin_metadata) + } +} + +#[test_only] +module token_bridge::attest_token_tests { + use std::ascii::{Self}; + use std::string::{Self}; + use iota::coin::{Self}; + use iota::test_scenario::{Self}; + use wormhole::publish_message::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::asset_meta::{Self}; + use token_bridge::attest_token::{Self}; + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::coin_wrapped_7::{Self, COIN_WRAPPED_7}; + use token_bridge::native_asset::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + person, + return_state, + set_up_wormhole_and_token_bridge, + take_state, + }; + use token_bridge::token_registry::{Self}; + + #[test] + fun test_attest_token() { + use token_bridge::attest_token::{attest_token}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Publish coin. + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + let coin_meta = coin_native_10::take_metadata(scenario); + + // Emit `AssetMeta` payload. + let prepared_msg = + attest_token( + &mut token_bridge_state, + &coin_meta, + 1234, // nonce + ); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + // Check that asset is registered. + { + let registry = + state::borrow_token_registry(&token_bridge_state); + let verified = + token_registry::verified_asset(registry); + assert!(!token_registry::is_wrapped(&verified), 0); + + let asset = token_registry::borrow_native(registry); + + let expected_token_address = + native_asset::canonical_address(&coin_meta); + assert!( + native_asset::token_address(asset) == expected_token_address, + 0 + ); + assert!(native_asset::decimals(asset) == 10, 0); + + let ( + token_chain, + token_address + ) = native_asset::canonical_info(asset); + assert!(token_chain == chain_id(), 0); + assert!(token_address == expected_token_address, 0); + + assert!(native_asset::custody(asset) == 0, 0); + }; + + // Clean up for next call. + publish_message::destroy(prepared_msg); + + // Update metadata. + let new_symbol = { + use std::vector::{Self}; + + let symbol = coin::get_symbol(&coin_meta); + let buf = ascii::into_bytes(symbol); + vector::reverse(&mut buf); + + ascii::string(buf) + }; + + let new_name = coin::get_name(&coin_meta); + string::append(&mut new_name, string::utf8(b"??? and profit")); + + let treasury_cap = coin_native_10::take_treasury_cap(scenario); + coin::update_symbol(&treasury_cap, &mut coin_meta, new_symbol); + coin::update_name(&treasury_cap, &mut coin_meta, new_name); + + // We should be able to call `attest_token` any time after. + let prepared_msg = + attest_token( + &mut token_bridge_state, + &coin_meta, + 1234, // nonce + ); + + // Clean up. + publish_message::destroy(prepared_msg); + return_state(token_bridge_state); + coin_native_10::return_globals(treasury_cap, coin_meta); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_serialize_asset_meta() { + use token_bridge::attest_token::{serialize_asset_meta_test_only}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Publish coin. + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Proceed to next operation. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + let coin_meta = coin_native_10::take_metadata(scenario); + + // Emit `AssetMeta` payload. + let serialized = + serialize_asset_meta_test_only(&mut token_bridge_state, &coin_meta); + let expected_serialized = + asset_meta::serialize_test_only( + asset_meta::from_metadata_test_only(&coin_meta) + ); + assert!(serialized == expected_serialized, 0); + + // Update metadata. + let new_symbol = { + use std::vector::{Self}; + + let symbol = coin::get_symbol(&coin_meta); + let buf = ascii::into_bytes(symbol); + vector::reverse(&mut buf); + + ascii::string(buf) + }; + + let new_name = coin::get_name(&coin_meta); + string::append(&mut new_name, string::utf8(b"??? and profit")); + + let treasury_cap = coin_native_10::take_treasury_cap(scenario); + coin::update_symbol(&treasury_cap, &mut coin_meta, new_symbol); + coin::update_name(&treasury_cap, &mut coin_meta, new_name); + + // Check that the new serialization reflects updated metadata. + let expected_serialized = + asset_meta::serialize_test_only( + asset_meta::from_metadata_test_only(&coin_meta) + ); + assert!(serialized != expected_serialized, 0); + let updated_serialized = + serialize_asset_meta_test_only(&mut token_bridge_state, &coin_meta); + assert!(updated_serialized == expected_serialized, 0); + + // Clean up. + return_state(token_bridge_state); + coin_native_10::return_globals(treasury_cap, coin_meta); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = attest_token::E_FROM_CREATE_WRAPPED)] + fun test_cannot_attest_token_from_create_wrapped() { + use token_bridge::attest_token::{attest_token}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Publish coin. + coin_wrapped_7::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + let coin_meta = test_scenario::take_shared(scenario); + + // You shall not pass! + let prepared_msg = + attest_token( + &mut token_bridge_state, + &coin_meta, + 1234 // nonce + ); + + // Clean up. + publish_message::destroy(prepared_msg); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_attest_token_outdated_version() { + use token_bridge::attest_token::{attest_token}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Publish coin. + coin_wrapped_7::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + let coin_meta = test_scenario::take_shared(scenario); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + let prepared_msg = + attest_token( + &mut token_bridge_state, + &coin_meta, + 1234 // nonce + ); + + // Clean up. + publish_message::destroy(prepared_msg); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/complete_transfer.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/complete_transfer.move new file mode 100644 index 0000000000..ae58d044f6 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/complete_transfer.move @@ -0,0 +1,1228 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements two methods: `authorize_transfer` and +/// `redeem_relayer_payout`, which are to be executed in a transaction block in +/// this order. +/// +/// `authorize_transfer` allows a contract to complete a Token Bridge transfer, +/// sending assets to the encoded recipient. The coin payout incentive in +/// redeeming the transfer is packaged in a `RelayerReceipt`. +/// +/// `redeem_relayer_payout` unpacks the `RelayerReceipt` to release the coin +/// containing the relayer fee amount. +/// +/// The purpose of splitting this transfer redemption into two steps is in case +/// Token Bridge needs to be upgraded and there is a breaking change for this +/// module, an integrator would not be left broken. It is discouraged to put +/// `authorize_transfer` in an integrator's package logic. Otherwise, this +/// integrator needs to be prepared to upgrade his contract to handle the latest +/// version of `complete_transfer`. +/// +/// Instead, an integrator is encouraged to execute a transaction block, which +/// executes `authorize_transfer` using the latest Token Bridge package ID and +/// to implement `redeem_relayer_payout` in his contract to consume this receipt. +/// This is similar to how an integrator with Wormhole is not meant to use +/// `vaa::parse_and_verify` in his contract in case the `vaa` module needs to +/// be upgraded due to a breaking change. +/// +/// See `transfer` module for serialization and deserialization of Wormhole +/// message payload. +module token_bridge::complete_transfer { + use iota::balance::{Self, Balance}; + use iota::coin::{Self, Coin}; + use iota::tx_context::{Self, TxContext}; + use wormhole::external_address::{Self, ExternalAddress}; + + use token_bridge::native_asset::{Self}; + use token_bridge::normalized_amount::{Self, NormalizedAmount}; + use token_bridge::state::{Self, State, LatestOnly}; + use token_bridge::token_registry::{Self, VerifiedAsset}; + use token_bridge::transfer::{Self}; + use token_bridge::vaa::{Self, TokenBridgeMessage}; + use token_bridge::wrapped_asset::{Self}; + + // Requires `handle_complete_transfer`. + friend token_bridge::complete_transfer_with_payload; + + /// Transfer not intended to be received on Iota. + const E_TARGET_NOT_SUI: u64 = 0; + /// Input token info does not match registered info. + const E_CANONICAL_TOKEN_INFO_MISMATCH: u64 = 1; + + /// Event reflecting when a transfer via `complete_transfer` or + /// `complete_transfer_with_payload` is successfully executed. + struct TransferRedeemed has drop, copy { + emitter_chain: u16, + emitter_address: ExternalAddress, + sequence: u64 + } + + #[allow(lint(coin_field))] + /// This type is only generated from `authorize_transfer` and can only be + /// redeemed using `redeem_relayer_payout`. Integrators running relayer + /// contracts are expected to implement `redeem_relayer_payout` within their + /// contracts and call `authorize_transfer` in a transaction block preceding + /// the method that consumes this receipt. + struct RelayerReceipt { + /// Coin of relayer fee payout. + payout: Coin + } + + /// `authorize_transfer` deserializes a token transfer VAA payload. Once the + /// transfer is authorized, an event (`TransferRedeemed`) is emitted to + /// reflect which Token Bridge this transfer originated from. The + /// `RelayerReceipt` returned wraps a `Coin` object containing a payout that + /// incentivizes someone to execute a transaction on behalf of the encoded + /// recipient. + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + /// + /// It is important for integrators to refrain from calling this method + /// within their contracts. This method is meant to be called in a + /// transaction block, passing the `RelayerReceipt` to a method which calls + /// `redeem_relayer_payout` within a contract. If in a circumstance where + /// this module has a breaking change in an upgrade, `redeem_relayer_payout` + /// will not be affected by this change. + /// + /// See `redeem_relayer_payout` for more details. + public fun authorize_transfer( + token_bridge_state: &mut State, + msg: TokenBridgeMessage, + ctx: &mut TxContext + ): RelayerReceipt { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // Emitting the transfer being redeemed (and disregard return value). + emit_transfer_redeemed(&msg); + + // Deserialize transfer message and process. + handle_complete_transfer( + &latest_only, + token_bridge_state, + vaa::take_payload(msg), + ctx + ) + } + + /// After a transfer is authorized, a relayer contract may unpack the + /// `RelayerReceipt` using this method. Coin representing the relaying + /// incentive from this receipt is returned. This method is meant to be + /// simple. It allows for a coordination with calling `authorize_upgrade` + /// before a method that implements `redeem_relayer_payout` in a transaction + /// block to consume this receipt. + /// + /// NOTE: Integrators of Token Bridge collecting relayer fee payouts from + /// these token transfers should be calling only this method from their + /// contracts. This method is not guarded by version control (thus not + /// requiring a reference to the Token Bridge `State` object), so it is + /// intended to work for any package version. + public fun redeem_relayer_payout( + receipt: RelayerReceipt + ): Coin { + let RelayerReceipt { payout } = receipt; + + payout + } + + /// This is a privileged method only used by `complete_transfer` and + /// `complete_transfer_with_payload` modules. This method validates the + /// encoded token info with the passed in coin type via the `TokenRegistry`. + /// The transfer amount is denormalized and either mints balance of + /// wrapped asset or withdraws balance from native asset custody. + /// + /// Depending on whether this coin is a Token Bridge wrapped asset or a + /// natively existing asset on Iota, the coin is either minted or withdrawn + /// from Token Bridge's custody. + public(friend) fun verify_and_bridge_out( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + token_chain: u16, + token_address: ExternalAddress, + target_chain: u16, + amount: NormalizedAmount + ): ( + VerifiedAsset, + Balance + ) { + // Verify that the intended chain ID for this transfer is for Iota. + assert!( + target_chain == wormhole::state::chain_id(), + E_TARGET_NOT_SUI + ); + + let asset_info = state::verified_asset(token_bridge_state); + assert!( + ( + token_chain == token_registry::token_chain(&asset_info) && + token_address == token_registry::token_address(&asset_info) + ), + E_CANONICAL_TOKEN_INFO_MISMATCH + ); + + // De-normalize amount in preparation to take `Balance`. + let raw_amount = + normalized_amount::to_raw( + amount, + token_registry::coin_decimals(&asset_info) + ); + + // If the token is wrapped by Token Bridge, we will mint these tokens. + // Otherwise, we will withdraw from custody. + let bridged_out = { + let registry = + state::borrow_mut_token_registry( + latest_only, + token_bridge_state + ); + if (token_registry::is_wrapped(&asset_info)) { + wrapped_asset::mint( + token_registry::borrow_mut_wrapped(registry), + raw_amount + ) + } else { + native_asset::withdraw( + token_registry::borrow_mut_native(registry), + raw_amount + ) + } + }; + + (asset_info, bridged_out) + } + + /// This method emits source information of the token transfer. Off-chain + /// processes may want to observe when transfers have been redeemed. + public(friend) fun emit_transfer_redeemed(msg: &TokenBridgeMessage): u16 { + let emitter_chain = vaa::emitter_chain(msg); + + // Emit Iota event with `TransferRedeemed`. + iota::event::emit( + TransferRedeemed { + emitter_chain, + emitter_address: vaa::emitter_address(msg), + sequence: vaa::sequence(msg) + } + ); + + emitter_chain + } + + fun handle_complete_transfer( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + transfer_vaa_payload: vector, + ctx: &mut TxContext + ): RelayerReceipt { + let ( + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee + ) = transfer::unpack(transfer::deserialize(transfer_vaa_payload)); + + let ( + asset_info, + bridged_out + ) = + verify_and_bridge_out( + latest_only, + token_bridge_state, + token_chain, + token_address, + recipient_chain, + amount + ); + + let recipient = external_address::to_address(recipient); + + // If the recipient did not redeem his own transfer, Token Bridge will + // split the withdrawn coins and send a portion to the transaction + // relayer. + let payout = if ( + normalized_amount::value(&relayer_fee) == 0 || + recipient == tx_context::sender(ctx) + ) { + balance::zero() + } else { + let payout_amount = + normalized_amount::to_raw( + relayer_fee, + token_registry::coin_decimals(&asset_info) + ); + balance::split(&mut bridged_out, payout_amount) + }; + + // Transfer tokens to the recipient. + iota::transfer::public_transfer( + coin::from_balance(bridged_out, ctx), + recipient + ); + + // Finally produce the receipt that a relayer can consume via + // `redeem_relayer_payout`. + RelayerReceipt { + payout: coin::from_balance(payout, ctx) + } + } + + #[test_only] + public fun burn(receipt: RelayerReceipt) { + coin::burn_for_testing(redeem_relayer_payout(receipt)); + } +} + +#[test_only] +module token_bridge::complete_transfer_tests { + use iota::coin::{Self, Coin}; + use iota::test_scenario::{Self}; + use wormhole::state::{chain_id}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + use token_bridge::coin_wrapped_12::{Self, COIN_WRAPPED_12}; + use token_bridge::coin_wrapped_7::{Self, COIN_WRAPPED_7}; + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::coin_native_4::{Self, COIN_NATIVE_4}; + use token_bridge::complete_transfer::{Self}; + use token_bridge::dummy_message::{Self}; + use token_bridge::native_asset::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + set_up_wormhole_and_token_bridge, + register_dummy_emitter, + return_state, + take_state, + three_people, + two_people + }; + use token_bridge::token_registry::{Self}; + use token_bridge::transfer::{Self}; + use token_bridge::vaa::{Self}; + use token_bridge::wrapped_asset::{Self}; + + struct OTHER_COIN_WITNESS has drop {} + + #[test] + /// An end-to-end test for complete transfer native with VAA. + fun test_complete_transfer_native_10_relayer_fee() { + use token_bridge::complete_transfer::{ + authorize_transfer, + redeem_relayer_payout + }; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_native_with_fee(); + + let (expected_recipient, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + let custody_amount = 500000; + coin_native_10::init_register_and_deposit( + scenario, + coin_deployer, + custody_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + // These will be checked later. + let expected_relayer_fee = 100000; + let expected_recipient_amount = 200000; + let expected_amount = expected_relayer_fee + expected_recipient_amount; + + // Scope to allow immutable reference to `TokenRegistry`. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == custody_amount, 0); + + // Verify transfer parameters. + let parsed = + transfer::deserialize_test_only( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + + let asset_info = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&asset_info); + let expected_token_address = + token_registry::token_address(&asset_info); + assert!(transfer::token_chain(&parsed) == expected_token_chain, 0); + assert!( + transfer::token_address(&parsed) == expected_token_address, + 0 + ); + + let coin_meta = test_scenario::take_shared(scenario); + + let decimals = coin::get_decimals(&coin_meta); + + test_scenario::return_shared(coin_meta); + + assert!( + transfer::raw_amount(&parsed, decimals) == expected_amount, + 0 + ); + + assert!( + transfer::raw_relayer_fee(&parsed, decimals) == expected_relayer_fee, + 0 + ); + assert!( + transfer::recipient_as_address(&parsed) == expected_recipient, + 0 + ); + assert!(transfer::recipient_chain(&parsed) == chain_id(), 0); + + // Clean up. + transfer::destroy(parsed); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let payout = redeem_relayer_payout(receipt); + assert!(coin::value(&payout) == expected_relayer_fee, 0); + + // TODO: Check for one event? `TransferRedeemed`. + let _effects = test_scenario::next_tx(scenario, tx_relayer); + + // Check recipient's `Coin`. + let received = + test_scenario::take_from_address>( + scenario, + expected_recipient + ); + assert!(coin::value(&received) == expected_recipient_amount, 0); + + // And check remaining amount in custody. + let registry = state::borrow_token_registry(&token_bridge_state); + let remaining = custody_amount - expected_amount; + { + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == remaining, 0); + }; + + // Clean up. + coin::burn_for_testing(payout); + coin::burn_for_testing(received); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// An end-to-end test for complete transfer native with VAA. + fun test_complete_transfer_native_4_relayer_fee() { + use token_bridge::complete_transfer::{ + authorize_transfer, + redeem_relayer_payout + }; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_native_with_fee(); + + let (expected_recipient, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + let custody_amount = 5000; + coin_native_4::init_register_and_deposit( + scenario, + coin_deployer, + custody_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + // These will be checked later. + let expected_relayer_fee = 1000; + let expected_recipient_amount = 2000; + let expected_amount = expected_relayer_fee + expected_recipient_amount; + + // Scope to allow immutable reference to `TokenRegistry`. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == custody_amount, 0); + + // Verify transfer parameters. + let parsed = + transfer::deserialize_test_only( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + + let asset_info = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&asset_info); + let expected_token_address = + token_registry::token_address(&asset_info); + assert!(transfer::token_chain(&parsed) == expected_token_chain, 0); + assert!( + transfer::token_address(&parsed) == expected_token_address, + 0 + ); + + let coin_meta = test_scenario::take_shared(scenario); + let decimals = coin::get_decimals(&coin_meta); + test_scenario::return_shared(coin_meta); + + assert!( + transfer::raw_amount(&parsed, decimals) == expected_amount, + 0 + ); + + assert!( + transfer::raw_relayer_fee(&parsed, decimals) == expected_relayer_fee, + 0 + ); + assert!( + transfer::recipient_as_address(&parsed) == expected_recipient, + 0 + ); + assert!(transfer::recipient_chain(&parsed) == chain_id(), 0); + + // Clean up. + transfer::destroy(parsed); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let payout = redeem_relayer_payout(receipt); + assert!(coin::value(&payout) == expected_relayer_fee, 0); + + // TODO: Check for one event? `TransferRedeemed`. + let _effects = test_scenario::next_tx(scenario, tx_relayer); + + // Check recipient's `Coin`. + let received = + test_scenario::take_from_address>( + scenario, + expected_recipient + ); + assert!(coin::value(&received) == expected_recipient_amount, 0); + + // And check remaining amount in custody. + let registry = state::borrow_token_registry(&token_bridge_state); + let remaining = custody_amount - expected_amount; + { + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == remaining, 0); + }; + + // Clean up. + coin::burn_for_testing(payout); + coin::burn_for_testing(received); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// An end-to-end test for complete transfer wrapped with VAA. + fun test_complete_transfer_wrapped_7_relayer_fee() { + use token_bridge::complete_transfer::{ + authorize_transfer, + redeem_relayer_payout + }; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_wrapped_7_with_fee(); + + let (expected_recipient, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + coin_wrapped_7::init_and_register(scenario, coin_deployer); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + // These will be checked later. + let expected_relayer_fee = 1000; + let expected_recipient_amount = 2000; + let expected_amount = expected_relayer_fee + expected_recipient_amount; + + // Scope to allow immutable reference to `TokenRegistry`. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == 0, 0); + + // Verify transfer parameters. + let parsed = + transfer::deserialize_test_only( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + + let asset_info = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&asset_info); + let expected_token_address = + token_registry::token_address(&asset_info); + assert!(transfer::token_chain(&parsed) == expected_token_chain, 0); + assert!( + transfer::token_address(&parsed) == expected_token_address, + 0 + ); + + let coin_meta = test_scenario::take_shared(scenario); + let decimals = coin::get_decimals(&coin_meta); + test_scenario::return_shared(coin_meta); + + assert!( + transfer::raw_amount(&parsed, decimals) == expected_amount, + 0 + ); + + assert!( + transfer::raw_relayer_fee(&parsed, decimals) == expected_relayer_fee, + 0 + ); + assert!( + transfer::recipient_as_address(&parsed) == expected_recipient, + 0 + ); + assert!(transfer::recipient_chain(&parsed) == chain_id(), 0); + + // Clean up. + transfer::destroy(parsed); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let payout = redeem_relayer_payout(receipt); + assert!(coin::value(&payout) == expected_relayer_fee, 0); + + // TODO: Check for one event? `TransferRedeemed`. + let _effects = test_scenario::next_tx(scenario, tx_relayer); + + // Check recipient's `Coin`. + let received = + test_scenario::take_from_address>( + scenario, + expected_recipient + ); + assert!(coin::value(&received) == expected_recipient_amount, 0); + + // And check that the amount is the total wrapped supply. + let registry = state::borrow_token_registry(&token_bridge_state); + { + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == expected_amount, 0); + }; + + // Clean up. + coin::burn_for_testing(payout); + coin::burn_for_testing(received); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// An end-to-end test for complete transfer wrapped with VAA. + fun test_complete_transfer_wrapped_12_relayer_fee() { + use token_bridge::complete_transfer::{ + authorize_transfer, + redeem_relayer_payout + }; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_wrapped_12_with_fee(); + + let (expected_recipient, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + coin_wrapped_12::init_and_register(scenario, coin_deployer); + + // Ignore effects. + // + // NOTE: `tx_relayer` != `expected_recipient`. + assert!(expected_recipient != tx_relayer, 0); + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + // These will be checked later. + let expected_relayer_fee = 1000; + let expected_recipient_amount = 2000; + let expected_amount = expected_relayer_fee + expected_recipient_amount; + + // Scope to allow immutable reference to `TokenRegistry`. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == 0, 0); + + // Verify transfer parameters. + let parsed = + transfer::deserialize_test_only( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + + let asset_info = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&asset_info); + let expected_token_address = + token_registry::token_address(&asset_info); + assert!(transfer::token_chain(&parsed) == expected_token_chain, 0); + assert!(transfer::token_address(&parsed) == expected_token_address, 0); + + let coin_meta = test_scenario::take_shared(scenario); + let decimals = coin::get_decimals(&coin_meta); + test_scenario::return_shared(coin_meta); + + assert!(transfer::raw_amount(&parsed, decimals) == expected_amount, 0); + + assert!( + transfer::raw_relayer_fee(&parsed, decimals) == expected_relayer_fee, + 0 + ); + assert!( + transfer::recipient_as_address(&parsed) == expected_recipient, + 0 + ); + assert!(transfer::recipient_chain(&parsed) == chain_id(), 0); + + // Clean up. + transfer::destroy(parsed); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let payout = redeem_relayer_payout(receipt); + assert!(coin::value(&payout) == expected_relayer_fee, 0); + + // TODO: Check for one event? `TransferRedeemed`. + let _effects = test_scenario::next_tx(scenario, tx_relayer); + + // Check recipient's `Coin`. + let received = + test_scenario::take_from_address>( + scenario, + expected_recipient + ); + assert!(coin::value(&received) == expected_recipient_amount, 0); + + // And check that the amount is the total wrapped supply. + let registry = state::borrow_token_registry(&token_bridge_state); + { + let asset = token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == expected_amount, 0); + }; + + // Clean up. + coin::burn_for_testing(payout); + coin::burn_for_testing(received); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// An end-to-end test for complete transfer native with VAA. The encoded VAA + /// specifies a nonzero fee, however the `recipient` should receive the full + /// amount for self redeeming the transfer. + fun test_complete_transfer_native_10_relayer_fee_self_redemption() { + use token_bridge::complete_transfer::{ + authorize_transfer, + redeem_relayer_payout + }; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_native_with_fee(); + + let (expected_recipient, _, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(expected_recipient); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + let custody_amount = 500000; + coin_native_10::init_register_and_deposit( + scenario, + coin_deployer, + custody_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, expected_recipient); + + let token_bridge_state = take_state(scenario); + + // NOTE: Although there is a fee encoded in the VAA, the relayer + // shouldn't receive this fee. The `expected_relayer_fee` should + // go to the recipient. + // + // These values will be used later. + let expected_relayer_fee = 0; + let encoded_relayer_fee = 100000; + let expected_recipient_amount = 300000; + let expected_amount = expected_relayer_fee + expected_recipient_amount; + + // Scope to allow immutable reference to `TokenRegistry`. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == custody_amount, 0); + + // Verify transfer parameters. + let parsed = + transfer::deserialize_test_only( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + + let asset_info = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&asset_info); + let expected_token_address = + token_registry::token_address(&asset_info); + assert!(transfer::token_chain(&parsed) == expected_token_chain, 0); + assert!(transfer::token_address(&parsed) == expected_token_address, 0); + + let coin_meta = test_scenario::take_shared(scenario); + + let decimals = coin::get_decimals(&coin_meta); + + test_scenario::return_shared(coin_meta); + + assert!(transfer::raw_amount(&parsed, decimals) == expected_amount, 0); + assert!( + transfer::raw_relayer_fee(&parsed, decimals) == encoded_relayer_fee, + 0 + ); + assert!( + transfer::recipient_as_address(&parsed) == expected_recipient, + 0 + ); + assert!(transfer::recipient_chain(&parsed) == chain_id(), 0); + + // Clean up. + transfer::destroy(parsed); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, expected_recipient); + + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let payout = redeem_relayer_payout(receipt); + assert!(coin::value(&payout) == expected_relayer_fee, 0); + + // TODO: Check for one event? `TransferRedeemed`. + let _effects = test_scenario::next_tx(scenario, expected_recipient); + + // Check recipient's `Coin`. + let received = + test_scenario::take_from_address>( + scenario, + expected_recipient + ); + assert!(coin::value(&received) == expected_recipient_amount, 0); + + // And check remaining amount in custody. + let registry = state::borrow_token_registry(&token_bridge_state); + let remaining = custody_amount - expected_amount; + { + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == remaining, 0); + }; + + // Clean up. + coin::burn_for_testing(payout); + coin::burn_for_testing(received); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure( + abort_code = complete_transfer::E_CANONICAL_TOKEN_INFO_MISMATCH + )] + /// This test verifies that `authorize_transfer` reverts when called with + /// a native COIN_TYPE that's not encoded in the VAA. + fun test_cannot_authorize_transfer_native_invalid_coin_type() { + use token_bridge::complete_transfer::{authorize_transfer}; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_native_with_fee(); + + let (_, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + let custody_amount_coin_10 = 500000; + coin_native_10::init_register_and_deposit( + scenario, + coin_deployer, + custody_amount_coin_10 + ); + + // Register a second native asset. + let custody_amount_coin_4 = 69420; + coin_native_4::init_register_and_deposit( + scenario, + coin_deployer, + custody_amount_coin_4 + ); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + // Scope to allow immutable reference to `TokenRegistry`. This verifies + // that both coin types have been registered. + { + let registry = state::borrow_token_registry(&token_bridge_state); + + // COIN_10. + let coin_10 = + token_registry::borrow_native(registry); + assert!( + native_asset::custody(coin_10) == custody_amount_coin_10, + 0 + ); + + // COIN_4. + let coin_4 = token_registry::borrow_native(registry); + assert!(native_asset::custody(coin_4) == custody_amount_coin_4, 0); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + // NOTE: this call should revert since the transfer VAA is for + // a coin of type COIN_NATIVE_10. However, the `complete_transfer` + // method is called using the COIN_NATIVE_4 type. + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + complete_transfer::burn(receipt); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = complete_transfer::E_CANONICAL_TOKEN_INFO_MISMATCH + )] + /// This test verifies that `authorize_transfer` reverts when called with + /// a wrapped COIN_TYPE that's not encoded in the VAA. + fun test_cannot_authorize_transfer_wrapped_invalid_coin_type() { + use token_bridge::complete_transfer::{authorize_transfer}; + + let transfer_vaa = dummy_message::encoded_transfer_vaa_wrapped_12_with_fee(); + + let (expected_recipient, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Register both wrapped coin types (12 and 7). + coin_wrapped_12::init_and_register(scenario, coin_deployer); + coin_wrapped_7::init_and_register(scenario, coin_deployer); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + // NOTE: `tx_relayer` != `expected_recipient`. + assert!(expected_recipient != tx_relayer, 0); + + let token_bridge_state = take_state(scenario); + + // Scope to allow immutable reference to `TokenRegistry`. This verifies + // that both coin types have been registered. + { + let registry = state::borrow_token_registry(&token_bridge_state); + + let coin_12 = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(coin_12) == 0, 0); + + let coin_7 = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(coin_7) == 0, 0); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + // NOTE: this call should revert since the transfer VAA is for + // a coin of type COIN_WRAPPED_12. However, the `authorize_transfer` + // method is called using the COIN_WRAPPED_7 type. + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + complete_transfer::burn(receipt); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = complete_transfer::E_TARGET_NOT_SUI)] + /// This test verifies that `authorize_transfer` reverts when a transfer is + /// sent to the wrong target blockchain (chain ID != 21). + fun test_cannot_authorize_transfer_wrapped_12_invalid_target_chain() { + use token_bridge::complete_transfer::{authorize_transfer}; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_wrapped_12_invalid_target_chain(); + + let (expected_recipient, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + coin_wrapped_12::init_and_register(scenario, coin_deployer); + + // Ignore effects. + // + // NOTE: `tx_relayer` != `expected_recipient`. + assert!(expected_recipient != tx_relayer, 0); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + // NOTE: this call should revert since the target chain encoded is + // chain 69 instead of chain 21 (Iota). + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + complete_transfer::burn(receipt); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_complete_transfer_outdated_version() { + use token_bridge::complete_transfer::{authorize_transfer}; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_native_with_fee(); + + let (tx_relayer, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + let custody_amount = 500000; + coin_native_10::init_register_and_deposit( + scenario, + coin_deployer, + custody_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + complete_transfer::burn(receipt); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/complete_transfer_with_payload.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/complete_transfer_with_payload.move new file mode 100644 index 0000000000..4489e82945 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/complete_transfer_with_payload.move @@ -0,0 +1,776 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements two methods: `authorize_transfer` and `redeem_coin`, +/// which are to be executed in a transaction block in this order. +/// +/// `authorize_transfer` allows a contract to complete a Token Bridge transfer +/// with arbitrary payload. This deserialized `TransferWithPayload` with the +/// bridged balance and source chain ID are packaged in a `RedeemerReceipt`. +/// +/// `redeem_coin` unpacks the `RedeemerReceipt` and checks whether the specified +/// `EmitterCap` is the specified redeemer for this transfer. If he is the +/// correct redeemer, the balance is unpacked and transformed into `Coin` and +/// is returned alongside `TransferWithPayload` and source chain ID. +/// +/// The purpose of splitting this transfer redemption into two steps is in case +/// Token Bridge needs to be upgraded and there is a breaking change for this +/// module, an integrator would not be left broken. It is discouraged to put +/// `authorize_transfer` in an integrator's package logic. Otherwise, this +/// integrator needs to be prepared to upgrade his contract to handle the latest +/// version of `complete_transfer_with_payload`. +/// +/// Instead, an integrator is encouraged to execute a transaction block, which +/// executes `authorize_transfer` using the latest Token Bridge package ID and +/// to implement `redeem_coin` in his contract to consume this receipt. This is +/// similar to how an integrator with Wormhole is not meant to use +/// `vaa::parse_and_verify` in his contract in case the `vaa` module needs to +/// be upgraded due to a breaking change. +/// +/// Like in `complete_transfer`, a VAA with an encoded transfer can be redeemed +/// only once. +/// +/// See `transfer_with_payload` module for serialization and deserialization of +/// Wormhole message payload. +module token_bridge::complete_transfer_with_payload { + use iota::coin::{Self, Coin}; + use iota::object::{Self}; + use iota::tx_context::{TxContext}; + use wormhole::emitter::{EmitterCap}; + + use token_bridge::complete_transfer::{Self}; + use token_bridge::state::{Self, State, LatestOnly}; + use token_bridge::transfer_with_payload::{Self, TransferWithPayload}; + use token_bridge::vaa::{Self, TokenBridgeMessage}; + + /// `EmitterCap` address does not agree with encoded redeemer. + const E_INVALID_REDEEMER: u64 = 0; + + #[allow(lint(coin_field))] + /// This type is only generated from `authorize_transfer` and can only be + /// redeemed using `redeem_coin`. Integrators are expected to implement + /// `redeem_coin` within their contracts and call `authorize_transfer` in a + /// transaction block preceding the method that consumes this receipt. The + /// only way to destroy this receipt is calling `redeem_coin` with an + /// `EmitterCap` generated from the `wormhole::emitter` module, whose ID is + /// the expected redeemer for this token transfer. + struct RedeemerReceipt { + /// Which chain ID this transfer originated from. + source_chain: u16, + /// Deserialized transfer info. + parsed: TransferWithPayload, + /// Coin of bridged asset. + bridged_out: Coin + } + + /// `authorize_transfer` deserializes a token transfer VAA payload, which + /// encodes its own arbitrary payload (which has meaning to the redeemer). + /// Once the transfer is authorized, an event (`TransferRedeemed`) is + /// emitted to reflect which Token Bridge this transfer originated from. + /// The `RedeemerReceipt` returned wraps a balance reflecting the encoded + /// transfer amount along with the source chain and deserialized + /// `TransferWithPayload`. + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + /// + /// It is important for integrators to refrain from calling this method + /// within their contracts. This method is meant to be called in a + /// transaction block, passing the `RedeemerReceipt` to a method which calls + /// `redeem_coin` within a contract. If in a circumstance where this module + /// has a breaking change in an upgrade, `redeem_coin` will not be affected + /// by this change. + /// + /// See `redeem_coin` for more details. + public fun authorize_transfer( + token_bridge_state: &mut State, + msg: TokenBridgeMessage, + ctx: &mut TxContext + ): RedeemerReceipt { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // Emitting the transfer being redeemed. + // + // NOTE: We save the emitter chain ID to save the integrator from + // having to `parse_and_verify` the same encoded VAA to get this info. + let source_chain = + complete_transfer::emit_transfer_redeemed(&msg); + + // Finally deserialize the Wormhole message payload and handle bridging + // out token of a given coin type. + handle_authorize_transfer( + &latest_only, + token_bridge_state, + source_chain, + vaa::take_payload(msg), + ctx + ) + } + + /// After a transfer is authorized, only a valid redeemer may unpack the + /// `RedeemerReceipt`. The specified `EmitterCap` is the only authorized + /// redeemer of the transfer. Once the redeemer is validated, coin from + /// this receipt of the specified coin type is returned alongside the + /// deserialized `TransferWithPayload` and source chain ID. + /// + /// NOTE: Integrators of Token Bridge redeeming these token transfers should + /// be calling only this method from their contracts. This method is not + /// guarded by version control (thus not requiring a reference to the + /// Token Bridge `State` object), so it is intended to work for any package + /// version. + public fun redeem_coin( + emitter_cap: &EmitterCap, + receipt: RedeemerReceipt + ): ( + Coin, + TransferWithPayload, + u16 // `wormhole::vaa::emitter_chain` + ) { + let RedeemerReceipt { source_chain, parsed, bridged_out } = receipt; + + // Transfer must be redeemed by the contract's registered Wormhole + // emitter. + let redeemer = transfer_with_payload::redeemer_id(&parsed); + assert!(redeemer == object::id(emitter_cap), E_INVALID_REDEEMER); + + // Create coin from balance and return other unpacked members of receipt. + (bridged_out, parsed, source_chain) + } + + fun handle_authorize_transfer( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + source_chain: u16, + transfer_vaa_payload: vector, + ctx: &mut TxContext + ): RedeemerReceipt { + // Deserialize for processing. + let parsed = transfer_with_payload::deserialize(transfer_vaa_payload); + + // Handle bridging assets out to be returned to method caller. + // + // See `complete_transfer` module for more info. + let ( + _, + bridged_out, + ) = + complete_transfer::verify_and_bridge_out( + latest_only, + token_bridge_state, + transfer_with_payload::token_chain(&parsed), + transfer_with_payload::token_address(&parsed), + transfer_with_payload::redeemer_chain(&parsed), + transfer_with_payload::amount(&parsed) + ); + + RedeemerReceipt { + source_chain, + parsed, + bridged_out: coin::from_balance(bridged_out, ctx) + } + } + + #[test_only] + public fun burn(receipt: RedeemerReceipt) { + let RedeemerReceipt { + source_chain: _, + parsed: _, + bridged_out + } = receipt; + coin::burn_for_testing(bridged_out); + } +} + +#[test_only] +module token_bridge::complete_transfer_with_payload_tests { + use iota::coin::{Self}; + use iota::object::{Self}; + use iota::test_scenario::{Self}; + use wormhole::emitter::{Self}; + use wormhole::state::{chain_id}; + use wormhole::wormhole_scenario::{new_emitter, parse_and_verify_vaa}; + + use token_bridge::coin_wrapped_12::{Self, COIN_WRAPPED_12}; + use token_bridge::complete_transfer_with_payload::{Self}; + use token_bridge::complete_transfer::{Self}; + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::dummy_message::{Self}; + use token_bridge::native_asset::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + register_dummy_emitter, + return_state, + set_up_wormhole_and_token_bridge, + take_state, + two_people + }; + use token_bridge::token_registry::{Self}; + use token_bridge::transfer_with_payload::{Self}; + use token_bridge::vaa::{Self}; + use token_bridge::wrapped_asset::{Self}; + + #[test] + /// Test the public-facing function authorize_transfer. + /// using a native transfer VAA_ATTESTED_DECIMALS_10. + fun test_complete_transfer_with_payload_native_asset() { + use token_bridge::complete_transfer_with_payload::{ + authorize_transfer, + redeem_coin + }; + + let transfer_vaa = + dummy_message::encoded_transfer_with_payload_vaa_native(); + + let (user, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register Iota as a foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Initialize native token. + let mint_amount = 1000000; + coin_native_10::init_register_and_deposit( + scenario, + coin_deployer, + mint_amount + ); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + { + let asset = token_registry::borrow_native( + state::borrow_token_registry(&token_bridge_state) + ); + assert!(native_asset::custody(asset) == mint_amount, 0); + }; + + // Set up dummy `EmitterCap` as the expected redeemer. + let emitter_cap = emitter::dummy(); + + // Verify that the emitter cap is the expected redeemer. + let expected_transfer = + transfer_with_payload::deserialize( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + assert!( + transfer_with_payload::redeemer_id(&expected_transfer) == object::id(&emitter_cap), + 0 + ); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + // Execute authorize_transfer. + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let ( + bridged, + parsed_transfer, + source_chain + ) = redeem_coin(&emitter_cap, receipt); + + assert!(source_chain == expected_source_chain, 0); + + // Assert coin value, source chain, and parsed transfer details are correct. + // We expect the coin value to be 300000, because that's in terms of + // 10 decimals. The amount specified in the VAA_ATTESTED_DECIMALS_12 is 3000, because that's + // in terms of 8 decimals. + let expected_bridged = 300000; + assert!(coin::value(&bridged) == expected_bridged, 0); + + // Amount left on custody should be whatever is left remaining after + // the transfer. + let remaining = mint_amount - expected_bridged; + { + let asset = token_registry::borrow_native( + state::borrow_token_registry(&token_bridge_state) + ); + assert!(native_asset::custody(asset) == remaining, 0); + }; + + // Verify token info. + let registry = state::borrow_token_registry(&token_bridge_state); + let verified = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&verified); + let expected_token_address = token_registry::token_address(&verified); + assert!(expected_token_chain == chain_id(), 0); + assert!( + transfer_with_payload::token_chain(&parsed_transfer) == expected_token_chain, + 0 + ); + assert!( + transfer_with_payload::token_address(&parsed_transfer) == expected_token_address, + 0 + ); + + // Verify transfer by serializing both parsed and expected. + let serialized = transfer_with_payload::serialize(parsed_transfer); + let expected_serialized = + transfer_with_payload::serialize(expected_transfer); + assert!(serialized == expected_serialized, 0); + + // Clean up. + return_state(token_bridge_state); + coin::burn_for_testing(bridged); + emitter::destroy_test_only(emitter_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// Test the public-facing functions `authorize_transfer` and `redeem_coin`. + /// Use an actual devnet Wormhole complete transfer with payload + /// VAA_ATTESTED_DECIMALS_12. + /// + /// This test confirms that: + /// - `authorize_transfer` with `redeem_coin` deserializes the encoded + /// transfer and recovers the source chain, payload, and additional + /// transfer details wrapped in a redeemer receipt. + /// - a wrapped coin with the correct value is minted by the bridge + /// and returned by authorize_transfer + /// + fun test_complete_transfer_with_payload_wrapped_asset() { + use token_bridge::complete_transfer_with_payload::{ + authorize_transfer, + redeem_coin + }; + + let transfer_vaa = + dummy_message::encoded_transfer_with_payload_wrapped_12(); + + let (user, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register chain ID 2 as a foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Register wrapped token. + coin_wrapped_12::init_and_register(scenario, coin_deployer); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + // Set up dummy `EmitterCap` as the expected redeemer. + let emitter_cap = emitter::dummy(); + + // Verify that the emitter cap is the expected redeemer. + let expected_transfer = + transfer_with_payload::deserialize( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + assert!( + transfer_with_payload::redeemer_id(&expected_transfer) == object::id(&emitter_cap), + 0 + ); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + // Execute authorize_transfer. + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let ( + bridged, + parsed_transfer, + source_chain + ) = redeem_coin(&emitter_cap, receipt); + assert!(source_chain == expected_source_chain, 0); + + // Assert coin value, source chain, and parsed transfer details are correct. + let expected_bridged = 3000; + assert!(coin::value(&bridged) == expected_bridged, 0); + + // Total supply should equal the amount just minted. + let registry = state::borrow_token_registry(&token_bridge_state); + { + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == expected_bridged, 0); + }; + + // Verify token info. + let verified = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&verified); + let expected_token_address = token_registry::token_address(&verified); + assert!(expected_token_chain != chain_id(), 0); + assert!( + transfer_with_payload::token_chain(&parsed_transfer) == expected_token_chain, + 0 + ); + assert!( + transfer_with_payload::token_address(&parsed_transfer) == expected_token_address, + 0 + ); + + // Verify transfer by serializing both parsed and expected. + let serialized = transfer_with_payload::serialize(parsed_transfer); + let expected_serialized = + transfer_with_payload::serialize(expected_transfer); + assert!(serialized == expected_serialized, 0); + + // Clean up. + return_state(token_bridge_state); + coin::burn_for_testing(bridged); + emitter::destroy_test_only(emitter_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure( + abort_code = complete_transfer_with_payload::E_INVALID_REDEEMER, + )] + /// Test the public-facing function authorize_transfer. + /// This test fails because the ecmitter_cap (recipient) is incorrect (0x2 instead of 0x3). + /// + fun test_cannot_complete_transfer_with_payload_invalid_redeemer() { + use token_bridge::complete_transfer_with_payload::{ + authorize_transfer, + redeem_coin + }; + + let transfer_vaa = + dummy_message::encoded_transfer_with_payload_wrapped_12(); + + let (user, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register chain ID 2 as a foreign emitter. + register_dummy_emitter(scenario, 2); + + // Register wrapped asset with 12 decimals. + coin_wrapped_12::init_and_register(scenario, coin_deployer); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + let parsed = + transfer_with_payload::deserialize( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + + // Because the vaa expects the dummy emitter as the redeemer, we need + // to generate another emitter. + let emitter_cap = new_emitter(scenario); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + assert!( + transfer_with_payload::redeemer_id(&parsed) != object::id(&emitter_cap), + 0 + ); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + // You shall not pass! + let ( + bridged_out, + _, + _ + ) = redeem_coin(&emitter_cap, receipt); + + // Clean up. + coin::burn_for_testing(bridged_out); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = complete_transfer::E_CANONICAL_TOKEN_INFO_MISMATCH + )] + /// This test demonstrates that the `CoinType` specified for the token + /// redemption must agree with the canonical token info encoded in the VAA_ATTESTED_DECIMALS_12, + /// which is registered with the Token Bridge. + fun test_cannot_complete_transfer_with_payload_wrong_coin_type() { + use token_bridge::complete_transfer_with_payload::{ + authorize_transfer + }; + + let transfer_vaa = + dummy_message::encoded_transfer_with_payload_wrapped_12(); + + let (user, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register chain ID 2 as a foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Register wrapped token. + coin_wrapped_12::init_and_register(scenario, coin_deployer); + + // Also register unexpected token (in this case a native one). + coin_native_10::init_and_register(scenario, coin_deployer); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + let registry = state::borrow_token_registry(&token_bridge_state); + + // Set up dummy `EmitterCap` as the expected redeemer. + let emitter_cap = emitter::dummy(); + + // Verify that the emitter cap is the expected redeemer. + let expected_transfer = + transfer_with_payload::deserialize( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + assert!( + transfer_with_payload::redeemer_id(&expected_transfer) == object::id(&emitter_cap), + 0 + ); + + // Also verify that the encoded token info disagrees with the expected + // token info. + let verified = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&verified); + let expected_token_address = token_registry::token_address(&verified); + assert!( + transfer_with_payload::token_chain(&expected_transfer) != expected_token_chain, + 0 + ); + assert!( + transfer_with_payload::token_address(&expected_transfer) != expected_token_address, + 0 + ); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + // You shall not pass! + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + return_state(token_bridge_state); + complete_transfer_with_payload::burn(receipt); + emitter::destroy_test_only(emitter_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = complete_transfer::E_TARGET_NOT_SUI)] + /// This test verifies that `complete_transfer` reverts when a transfer is + /// sent to the wrong target blockchain (chain ID != 21). + fun test_cannot_complete_transfer_with_payload_wrapped_asset_invalid_target_chain() { + use token_bridge::complete_transfer_with_payload::{ + authorize_transfer + }; + + let transfer_vaa = + dummy_message::encoded_transfer_with_payload_wrapped_12_invalid_target_chain(); + + let (user, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register chain ID 2 as a foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Register wrapped token. + coin_wrapped_12::init_and_register(scenario, coin_deployer); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + // Set up dummy `EmitterCap` as the expected redeemer. + let emitter_cap = emitter::dummy(); + + // Verify that the emitter cap is the expected redeemer. + let expected_transfer = + transfer_with_payload::deserialize( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + assert!( + transfer_with_payload::redeemer_id(&expected_transfer) == object::id(&emitter_cap), + 0 + ); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + // You shall not pass! + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + complete_transfer_with_payload::burn(receipt); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_complete_transfer_with_payload_outdated_version() { + use token_bridge::complete_transfer_with_payload::{authorize_transfer}; + + let transfer_vaa = + dummy_message::encoded_transfer_with_payload_vaa_native(); + + let (user, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register Iota as a foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Initialize native token. + let mint_amount = 1000000; + coin_native_10::init_register_and_deposit( + scenario, + coin_deployer, + mint_amount + ); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + // Set up dummy `EmitterCap` as the expected redeemer. + let emitter_cap = emitter::dummy(); + + // Verify that the emitter cap is the expected redeemer. + let expected_transfer = + transfer_with_payload::deserialize( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + assert!( + transfer_with_payload::redeemer_id(&expected_transfer) == object::id(&emitter_cap), + 0 + ); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + complete_transfer_with_payload::burn(receipt); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/create_wrapped.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/create_wrapped.move new file mode 100644 index 0000000000..914fa3dfaa --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/create_wrapped.move @@ -0,0 +1,643 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements methods that create a specific coin type reflecting a +/// wrapped (foreign) asset, whose metadata is encoded in a VAA sent from +/// another network. +/// +/// Wrapped assets are created in two steps. +/// 1. `prepare_registration`: This method creates a new `TreasuryCap` for a +/// given coin type and wraps an encoded asset metadata VAA. We require a +/// one-time witness (OTW) to throw an explicit error (even though it is +/// redundant with what `create_currency` requires). This coin will +/// be published using this method, meaning the `init` method in that +/// untrusted package will have the asset's decimals hard-coded for its +/// coin metadata. A `WrappedAssetSetup` object is transferred to the +/// transaction sender. +/// 2. `complete_registration`: This method destroys the `WrappedAssetSetup` +/// object by unpacking its `TreasuryCap`, which will be warehoused in the +/// `TokenRegistry`. The shared coin metadata object will be updated to +/// reflect the contents of the encoded asset metadata payload. +/// +/// Wrapped asset metadata can also be updated with a new asset metadata VAA. +/// By calling `update_attestation`, Token Bridge verifies that the specific +/// coin type is registered and agrees with the encoded asset metadata's +/// canonical token info. `ForeignInfo` and the coin's metadata will be updated +/// based on the encoded asset metadata payload. +/// +/// See `state` and `wrapped_asset` modules for more details. +/// +/// References: +/// https://examples.iota.io/basics/one-time-witness.html +module token_bridge::create_wrapped { + use std::ascii::{Self}; + use std::option::{Self}; + use std::type_name::{Self}; + use iota::coin::{Self, TreasuryCap, CoinMetadata}; + use iota::object::{Self, UID}; + use iota::package::{UpgradeCap}; + use iota::transfer::{Self}; + use iota::tx_context::{TxContext}; + + use token_bridge::asset_meta::{Self}; + use token_bridge::normalized_amount::{max_decimals}; + use token_bridge::state::{Self, State}; + use token_bridge::token_registry::{Self}; + use token_bridge::vaa::{Self, TokenBridgeMessage}; + use token_bridge::wrapped_asset::{Self}; + + #[test_only] + use token_bridge::version_control::{Self, V__0_2_0 as V__CURRENT}; + + /// Failed one-time witness verification. + const E_BAD_WITNESS: u64 = 0; + /// Coin witness does not equal "COIN". + const E_INVALID_COIN_MODULE_NAME: u64 = 1; + /// Decimals value exceeds `MAX_DECIMALS` from `normalized_amount`. + const E_DECIMALS_EXCEED_WRAPPED_MAX: u64 = 2; + + /// A.K.A. "coin". + const COIN_MODULE_NAME: vector = b"coin"; + + /// Container holding new coin type's `TreasuryCap` and encoded asset metadata + /// VAA, which are required to complete this asset's registration. + struct WrappedAssetSetup has key, store { + id: UID, + treasury_cap: TreasuryCap + } + + /// This method is executed within the `init` method of an untrusted module, + /// which defines a one-time witness (OTW) type (`CoinType`). OTW is + /// required to ensure that only one `TreasuryCap` exists for `CoinType`. This + /// is similar to how a `TreasuryCap` is created in `coin::create_currency`. + /// + /// Because this method is stateless (i.e. no dependency on Token Bridge's + /// `State` object), the contract defers VAA verification to + /// `complete_registration` after this method has been executed. + public fun prepare_registration( + witness: CoinType, + decimals: u8, + ctx: &mut TxContext + ): WrappedAssetSetup { + let setup = prepare_registration_internal(witness, decimals, ctx); + + // Also make sure that this witness module name is literally "coin". + let module_name = type_name::get_module(&type_name::get()); + assert!( + ascii::into_bytes(module_name) == COIN_MODULE_NAME, + E_INVALID_COIN_MODULE_NAME + ); + + setup + } + + #[allow(lint(share_owned))] + /// This function performs the bulk of `prepare_registration`, except + /// checking the module name. This separation is useful for testing. + fun prepare_registration_internal( + witness: CoinType, + decimals: u8, + ctx: &mut TxContext + ): WrappedAssetSetup { + // Make sure there's only one instance of the type `CoinType`. This + // resembles the same check for `coin::create_currency`. + // Technically this check is redundant as it's performed by + // `coin::create_currency` below, but it doesn't hurt. + assert!(iota::types::is_one_time_witness(&witness), E_BAD_WITNESS); + + // Ensure that the decimals passed into this method do not exceed max + // decimals (see `normalized_amount` module). + assert!(decimals <= max_decimals(), E_DECIMALS_EXCEED_WRAPPED_MAX); + + // We initialise the currency with empty metadata. Later on, in the + // `complete_registration` call, when `CoinType` gets associated with a + // VAA, we update these fields. + let no_symbol = b""; + let no_name = b""; + let no_description = b""; + let no_icon_url = option::none(); + + let (treasury_cap, coin_meta) = + coin::create_currency( + witness, + decimals, + no_symbol, + no_name, + no_description, + no_icon_url, + ctx + ); + + // The CoinMetadata is turned into a shared object so that other + // functions (and wallets) can easily grab references to it. This is + // safe to do, as the metadata setters require a `TreasuryCap` for the + // coin too, which is held by the token bridge. + transfer::public_share_object(coin_meta); + + // Create `WrappedAssetSetup` object and transfer to transaction sender. + // The owner of this object will call `complete_registration` to destroy + // it. + WrappedAssetSetup { + id: object::new(ctx), + treasury_cap + } + } + + /// After executing `prepare_registration`, owner of `WrappedAssetSetup` + /// executes this method to complete this wrapped asset's registration. + /// + /// This method destroys `WrappedAssetSetup`, unpacking the `TreasuryCap` and + /// encoded asset metadata VAA. The deserialized asset metadata VAA is used + /// to update the associated `CoinMetadata`. + public fun complete_registration( + token_bridge_state: &mut State, + coin_meta: &mut CoinMetadata, + setup: WrappedAssetSetup, + coin_upgrade_cap: UpgradeCap, + msg: TokenBridgeMessage + ) { + // This capability ensures that the current build version is used. This + // call performs an additional check of whether `WrappedAssetSetup` was + // created using the current package. + let latest_only = + state::assert_latest_only_specified(token_bridge_state); + + let WrappedAssetSetup { + id, + treasury_cap + } = setup; + + // Finally destroy the object. + object::delete(id); + + // Deserialize to `AssetMeta`. + let token_meta = asset_meta::deserialize(vaa::take_payload(msg)); + + // `register_wrapped_asset` uses `token_registry::add_new_wrapped`, + // which will check whether the asset has already been registered and if + // the token chain ID is not Iota's. + // + // If both of these conditions are met, `register_wrapped_asset` will + // succeed and the new wrapped coin will be registered. + token_registry::add_new_wrapped( + state::borrow_mut_token_registry(&latest_only, token_bridge_state), + token_meta, + coin_meta, + treasury_cap, + coin_upgrade_cap + ); + } + + /// For registered wrapped assets, we can update `ForeignInfo` for a + /// given `CoinType` with a new asset meta VAA emitted from another network. + public fun update_attestation( + token_bridge_state: &mut State, + coin_meta: &mut CoinMetadata, + msg: TokenBridgeMessage + ) { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // Deserialize to `AssetMeta`. + let token_meta = asset_meta::deserialize(vaa::take_payload(msg)); + + // This asset must exist in the registry. + let registry = + state::borrow_mut_token_registry(&latest_only, token_bridge_state); + token_registry::assert_has(registry); + + // Now update wrapped. + wrapped_asset::update_metadata( + token_registry::borrow_mut_wrapped(registry), + coin_meta, + token_meta + ); + } + + public fun incomplete_metadata( + coin_meta: &CoinMetadata + ): bool { + use std::string::{bytes}; + use std::vector::{is_empty}; + + ( + is_empty(ascii::as_bytes(&coin::get_symbol(coin_meta))) && + is_empty(bytes(&coin::get_name(coin_meta))) && + is_empty(bytes(&coin::get_description(coin_meta))) && + std::option::is_none(&coin::get_icon_url(coin_meta)) + ) + } + + #[test_only] + public fun new_setup_test_only( + _version: Version, + witness: CoinType, + decimals: u8, + ctx: &mut TxContext + ): (WrappedAssetSetup, UpgradeCap) { + let setup = + prepare_registration_internal( + witness, + decimals, + ctx + ); + + let upgrade_cap = + iota::package::test_publish( + object::id_from_address(@token_bridge), + ctx + ); + + (setup, upgrade_cap) + } + + #[test_only] + public fun new_setup_current( + witness: CoinType, + decimals: u8, + ctx: &mut TxContext + ): (WrappedAssetSetup, UpgradeCap) { + new_setup_test_only( + version_control::current_version_test_only(), + witness, + decimals, + ctx + ) + } + + #[test_only] + public fun take_treasury_cap( + setup: WrappedAssetSetup + ): TreasuryCap { + let WrappedAssetSetup { + id, + treasury_cap + } = setup; + object::delete(id); + + treasury_cap + } +} + +#[test_only] +module token_bridge::create_wrapped_tests { + use iota::coin::{Self}; + use iota::test_scenario::{Self}; + use iota::test_utils::{Self}; + use iota::tx_context::{Self}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + use token_bridge::asset_meta::{Self}; + use token_bridge::coin_wrapped_12::{Self}; + use token_bridge::coin_wrapped_7::{Self}; + use token_bridge::create_wrapped::{Self}; + use token_bridge::state::{Self}; + use token_bridge::string_utils::{Self}; + use token_bridge::token_bridge_scenario::{ + register_dummy_emitter, + return_state, + set_up_wormhole_and_token_bridge, + take_state, + two_people + }; + use token_bridge::token_registry::{Self}; + use token_bridge::vaa::{Self}; + use token_bridge::version_control::{V__0_2_0 as V__CURRENT}; + use token_bridge::wrapped_asset::{Self}; + + struct NOT_A_WITNESS has drop {} + + struct CREATE_WRAPPED_TESTS has drop {} + + #[test] + #[expected_failure(abort_code = create_wrapped::E_BAD_WITNESS)] + fun test_cannot_prepare_registration_bad_witness() { + let ctx = &mut tx_context::dummy(); + + // You shall not pass! + let wrapped_asset_setup = + create_wrapped::prepare_registration( + NOT_A_WITNESS {}, + 3, + ctx + ); + + // Clean up. + test_utils::destroy(wrapped_asset_setup); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = create_wrapped::E_INVALID_COIN_MODULE_NAME)] + fun test_cannot_prepare_registration_invalid_coin_module_name() { + let ctx = &mut tx_context::dummy(); + + // You shall not pass! + let wrapped_asset_setup = + create_wrapped::prepare_registration< + CREATE_WRAPPED_TESTS, + V__CURRENT + >( + CREATE_WRAPPED_TESTS {}, + 3, + ctx + ); + + // Clean up. + test_utils::destroy(wrapped_asset_setup); + + abort 42 + } + + #[test] + fun test_complete_and_update_attestation() { + let (caller, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. Make sure `coin_deployer` receives + // `WrappedAssetSetup`. + test_scenario::next_tx(scenario, coin_deployer); + + // Publish coin. + let ( + wrapped_asset_setup, + upgrade_cap + ) = + create_wrapped::new_setup_current( + CREATE_WRAPPED_TESTS {}, + 8, + test_scenario::ctx(scenario) + ); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = + parse_and_verify_vaa(scenario, coin_wrapped_12::encoded_vaa()); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + let coin_meta = test_scenario::take_shared(scenario); + + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + wrapped_asset_setup, + upgrade_cap, + msg + ); + + let ( + token_address, + token_chain, + native_decimals, + symbol, + name + ) = asset_meta::unpack_test_only(coin_wrapped_12::token_meta()); + + // Check registry. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let verified = + token_registry::verified_asset(registry); + assert!(token_registry::is_wrapped(&verified), 0); + + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == 0, 0); + + // Decimals are capped for this wrapped asset. + assert!(coin::get_decimals(&coin_meta) == 8, 0); + + // Check metadata against asset metadata. + let info = wrapped_asset::info(asset); + assert!(wrapped_asset::token_chain(info) == token_chain, 0); + assert!(wrapped_asset::token_address(info) == token_address, 0); + assert!( + wrapped_asset::native_decimals(info) == native_decimals, + 0 + ); + assert!(coin::get_symbol(&coin_meta) == string_utils::to_ascii(&symbol), 0); + assert!(coin::get_name(&coin_meta) == name, 0); + }; + + + // Now update metadata. + let verified_vaa = + parse_and_verify_vaa( + scenario, + coin_wrapped_12::encoded_updated_vaa() + ); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + create_wrapped::update_attestation( + &mut token_bridge_state, + &mut coin_meta, + msg + ); + + // Check updated name and symbol. + let ( + _, + _, + _, + new_symbol, + new_name + ) = asset_meta::unpack_test_only(coin_wrapped_12::updated_token_meta()); + + assert!(symbol != new_symbol, 0); + + assert!(coin::get_symbol(&coin_meta) == string_utils::to_ascii(&new_symbol), 0); + + assert!(name != new_name, 0); + assert!(coin::get_name(&coin_meta) == new_name, 0); + + test_scenario::return_shared(coin_meta); + + // Clean up. + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wrapped_asset::E_ASSET_META_MISMATCH)] + fun test_cannot_update_attestation_wrong_canonical_info() { + let (caller, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. Make sure `coin_deployer` receives + // `WrappedAssetSetup`. + test_scenario::next_tx(scenario, coin_deployer); + + // Publish coin. + let ( + wrapped_asset_setup, + upgrade_cap + ) = + create_wrapped::new_setup_current( + CREATE_WRAPPED_TESTS {}, + 8, + test_scenario::ctx(scenario) + ); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = + parse_and_verify_vaa(scenario, coin_wrapped_12::encoded_vaa()); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + let coin_meta = test_scenario::take_shared(scenario); + + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + wrapped_asset_setup, + upgrade_cap, + msg + ); + // This VAA is for COIN_WRAPPED_7 metadata, which disagrees with + // COIN_WRAPPED_12. + let invalid_asset_meta_vaa = coin_wrapped_7::encoded_vaa(); + + let verified_vaa = + parse_and_verify_vaa(scenario, invalid_asset_meta_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + // You shall not pass! + create_wrapped::update_attestation( + &mut token_bridge_state, + &mut coin_meta, + msg + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = state::E_VERSION_MISMATCH)] + fun test_cannot_complete_registration_version_mismatch() { + let (caller, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. Make sure `coin_deployer` receives + // `WrappedAssetSetup`. + test_scenario::next_tx(scenario, coin_deployer); + + // Publish coin. + let ( + wrapped_asset_setup, + upgrade_cap + ) = + create_wrapped::new_setup_test_only( + token_bridge::version_control::dummy(), + CREATE_WRAPPED_TESTS {}, + 8, + test_scenario::ctx(scenario) + ); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = + parse_and_verify_vaa(scenario, coin_wrapped_12::encoded_vaa()); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + let coin_meta = test_scenario::take_shared(scenario); + + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + wrapped_asset_setup, + upgrade_cap, + msg + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_complete_registration_outdated_version() { + let (caller, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. Make sure `coin_deployer` receives + // `WrappedAssetSetup`. + test_scenario::next_tx(scenario, coin_deployer); + + // Publish coin. + let ( + wrapped_asset_setup, + upgrade_cap + ) = + create_wrapped::new_setup_current( + CREATE_WRAPPED_TESTS {}, + 8, + test_scenario::ctx(scenario) + ); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = + parse_and_verify_vaa(scenario, coin_wrapped_12::encoded_vaa()); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + let coin_meta = test_scenario::take_shared(scenario); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + wrapped_asset_setup, + upgrade_cap, + msg + ); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/datatypes/normalized_amount.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/datatypes/normalized_amount.move new file mode 100644 index 0000000000..c253b57ab4 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/datatypes/normalized_amount.move @@ -0,0 +1,167 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a container that stores the token transfer amount +/// encoded in a Token Bridge message. These amounts are capped at 8 decimals. +/// This means that any amount of a coin whose metadata defines its decimals +/// as some value greater than 8, the encoded amount will be normalized to +/// eight decimals (which will lead to some residual amount after the transfer). +/// For inbound transfers, this amount will be denormalized (scaled by the same +/// decimal difference). +module token_bridge::normalized_amount { + use iota::math::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Cursor}; + + /// The amounts in the token bridge payload are truncated to 8 decimals + /// in each of the contracts when sending tokens out, so there's no + /// precision beyond 10^-8. We could preserve the original number of + /// decimals when creating wrapped assets, and "untruncate" the amounts + /// on the way out by scaling back appropriately. This is what most + /// other chains do, but untruncating from 8 decimals to 18 decimals + /// loses log2(10^10) ~ 33 bits of precision, which we cannot afford on + /// Aptos (and Solana), as the coin type only has 64bits to begin with. + /// Contrast with Ethereum, where amounts are 256 bits. + /// So we cap the maximum decimals at 8 when creating a wrapped token. + const MAX_DECIMALS: u8 = 8; + + /// Container holding the value decoded from a Token Bridge transfer. + struct NormalizedAmount has store, copy, drop { + value: u64 + } + + public fun max_decimals(): u8 { + MAX_DECIMALS + } + + /// Utility function to cap decimal amount to 8. + public fun cap_decimals(decimals: u8): u8 { + if (decimals > MAX_DECIMALS) { + MAX_DECIMALS + } else { + decimals + } + } + + /// Create new `NormalizedAmount` of zero. + public fun default(): NormalizedAmount { + new(0) + } + + /// Retrieve underlying value. + public fun value(self: &NormalizedAmount): u64 { + self.value + } + + /// Retrieve underlying value as `u256`. + public fun to_u256(norm: NormalizedAmount): u256 { + (take_value(norm) as u256) + } + + /// Create new `NormalizedAmount` using raw amount and specified decimals. + public fun from_raw(amount: u64, decimals: u8): NormalizedAmount { + if (amount == 0) { + default() + } else if (decimals > MAX_DECIMALS) { + new(amount / math::pow(10, decimals - MAX_DECIMALS)) + } else { + new(amount) + } + } + + /// Denormalize `NormalizedAmount` using specified decimals. + public fun to_raw(norm: NormalizedAmount, decimals: u8): u64 { + let value = take_value(norm); + + if (value > 0 && decimals > MAX_DECIMALS) { + value * math::pow(10, decimals - MAX_DECIMALS) + } else { + value + } + } + + /// Transform `NormalizedAmount` to serialized (big-endian) u256. + public fun to_bytes(norm: NormalizedAmount): vector { + bytes32::to_bytes(bytes32::from_u256_be(to_u256(norm))) + } + + /// Read 32 bytes from `Cursor` and deserialize to u64, ensuring no + /// overflow. + public fun take_bytes(cur: &mut Cursor): NormalizedAmount { + // Amounts are encoded with 32 bytes. + new(bytes32::to_u64_be(bytes32::take_bytes(cur))) + } + + fun new(value: u64): NormalizedAmount { + NormalizedAmount { + value + } + } + + fun take_value(norm: NormalizedAmount): u64 { + let NormalizedAmount { value } = norm; + value + } +} + +#[test_only] +module token_bridge::normalized_amount_test { + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + + use token_bridge::normalized_amount::{Self}; + + #[test] + fun test_from_and_to_raw() { + // Use decimals > 8 to check truncation. + let decimals = 9; + let raw_amount = 12345678910111; + let normalized = normalized_amount::from_raw(raw_amount, decimals); + let denormalized = normalized_amount::to_raw(normalized, decimals); + assert!(denormalized == 10 * (raw_amount / 10), 0); + + // Use decimals <= 8 to check raw amount recovery. + let decimals = 5; + let normalized = normalized_amount::from_raw(raw_amount, decimals); + let denormalized = normalized_amount::to_raw(normalized, decimals); + assert!(denormalized == raw_amount, 0); + } + + #[test] + fun test_take_bytes() { + let cur = + cursor::new( + x"000000000000000000000000000000000000000000000000ffffffffffffffff" + ); + + let norm = normalized_amount::take_bytes(&mut cur); + assert!( + normalized_amount::value(&norm) == ((1u256 << 64) - 1 as u64), + 0 + ); + + // Clean up. + cursor::destroy_empty(cur); + } + + #[test] + #[expected_failure(abort_code = wormhole::bytes32::E_U64_OVERFLOW)] + fun test_cannot_take_bytes_overflow() { + let encoded_overflow = + x"0000000000000000000000000000000000000000000000010000000000000000"; + + let amount = { + let cur = cursor::new(encoded_overflow); + let value = bytes::take_u256_be(&mut cur); + cursor::destroy_empty(cur); + value + }; + assert!(amount == (1 << 64), 0); + + let cur = cursor::new(encoded_overflow); + + // You shall not pass! + normalized_amount::take_bytes(&mut cur); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/governance/register_chain.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/governance/register_chain.move new file mode 100644 index 0000000000..2255842ae6 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/governance/register_chain.move @@ -0,0 +1,297 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact registering a +/// foreign Token Bridge for a particular chain ID. +module token_bridge::register_chain { + use iota::table::{Self}; + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + + use token_bridge::state::{Self, State, LatestOnly}; + + /// Cannot register chain ID == 0. + const E_INVALID_EMITTER_CHAIN: u64 = 0; + /// Emitter already exists for a given chain ID. + const E_EMITTER_ALREADY_REGISTERED: u64 = 1; + + /// Specific governance payload ID (action) for registering foreign Token + /// Bridge contract address. + const ACTION_REGISTER_CHAIN: u8 = 1; + + struct GovernanceWitness has drop {} + + struct RegisterChain { + chain: u16, + contract_address: ExternalAddress, + } + + public fun authorize_governance( + token_bridge_state: &State + ): DecreeTicket { + governance_message::authorize_verify_global( + GovernanceWitness {}, + state::governance_chain(token_bridge_state), + state::governance_contract(token_bridge_state), + state::governance_module(), + ACTION_REGISTER_CHAIN + ) + } + + public fun register_chain( + token_bridge_state: &mut State, + receipt: DecreeReceipt + ): ( + u16, + ExternalAddress + ) { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + let payload = + governance_message::take_payload( + state::borrow_mut_consumed_vaas( + &latest_only, + token_bridge_state + ), + receipt + ); + + handle_register_chain(&latest_only, token_bridge_state, payload) + } + + fun handle_register_chain( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + governance_payload: vector + ): ( + u16, + ExternalAddress + ) { + // Deserialize the payload as amount to change the Wormhole fee. + let RegisterChain { + chain, + contract_address + } = deserialize(governance_payload); + + register_new_emitter( + latest_only, + token_bridge_state, + chain, + contract_address + ); + + (chain, contract_address) + } + + fun deserialize(payload: vector): RegisterChain { + let cur = cursor::new(payload); + + // This amount cannot be greater than max u64. + let chain = bytes::take_u16_be(&mut cur); + let contract_address = external_address::take_bytes(&mut cur); + + cursor::destroy_empty(cur); + + RegisterChain { chain, contract_address} + } + + /// Add a new Token Bridge emitter to the registry. This method will abort + /// if an emitter is already registered for a particular chain ID. + /// + /// See `register_chain` module for more info. + fun register_new_emitter( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + chain: u16, + contract_address: ExternalAddress + ) { + assert!(chain != 0, E_INVALID_EMITTER_CHAIN); + + let registry = + state::borrow_mut_emitter_registry(latest_only, token_bridge_state); + assert!( + !table::contains(registry, chain), + E_EMITTER_ALREADY_REGISTERED + ); + table::add(registry, chain, contract_address); + } + + #[test_only] + public fun register_new_emitter_test_only( + token_bridge_state: &mut State, + chain: u16, + contract_address: ExternalAddress + ) { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + register_new_emitter( + &latest_only, + token_bridge_state, + chain, + contract_address + ); + } + + #[test_only] + public fun action(): u8 { + ACTION_REGISTER_CHAIN + } +} + +#[test_only] +module token_bridge::register_chain_tests { + use iota::table::{Self}; + use iota::test_scenario::{Self}; + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self}; + use wormhole::governance_message::{Self}; + use wormhole::wormhole_scenario::{ + parse_and_verify_vaa, + verify_governance_vaa + }; + + use token_bridge::register_chain::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + person, + return_state, + set_up_wormhole_and_token_bridge, + take_state + }; + + const VAA_REGISTER_CHAIN_1: vector = + x"01000000000100dd8cf046ad6dd17b2b5130d236b3545350899ac33b5c9e93e4d8c3e0da718a351c3f76cb9ddb15a0f0d7db7b1dded2b5e79c2f6e76dde6d8ed4bcb9cb461eb480100bc614e0000000000010000000000000000000000000000000000000000000000000000000000000004000000000000000101000000000000000000000000000000000000000000546f6b656e4272696467650100000002000000000000000000000000deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + const VAA_REGISTER_SAME_CHAIN: vector = + x"01000000000100847ca782db7616135de4a835ed5b12ba7946bbd39f70ecd9912ec55bdc9cb6c6215c98d6ad5c8d7253c2bb0fb0f8df0dc6591408c366cf0c09e58abcfb8c0abe0000bc614e0000000000010000000000000000000000000000000000000000000000000000000000000004000000000000000101000000000000000000000000000000000000000000546f6b656e427269646765010000000200000000000000000000000000000000000000000000000000000000deafbeef"; + + #[test] + fun test_register_chain() { + // Testing this method. + use token_bridge::register_chain::{register_chain}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + // Check that the emitter is not registered. + let expected_chain = 2; + { + let registry = state::borrow_emitter_registry(&token_bridge_state); + assert!(!table::contains(registry, expected_chain), 0); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, VAA_REGISTER_CHAIN_1); + let ticket = register_chain::authorize_governance(&token_bridge_state); + let receipt = + verify_governance_vaa(scenario, verified_vaa, ticket); + let ( + chain, + contract_address + ) = register_chain(&mut token_bridge_state, receipt); + assert!(chain == expected_chain, 0); + + let expected_contract = + external_address::from_address( + @0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef + ); + assert!(contract_address == expected_contract, 0); + { + let registry = state::borrow_emitter_registry(&token_bridge_state); + assert!(*table::borrow(registry, expected_chain) == expected_contract, 0); + }; + + // Clean up. + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = register_chain::E_EMITTER_ALREADY_REGISTERED)] + fun test_cannot_register_chain_already_registered() { + // Testing this method. + use token_bridge::register_chain::{register_chain}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, VAA_REGISTER_CHAIN_1); + let ticket = register_chain::authorize_governance(&token_bridge_state); + let receipt = + verify_governance_vaa(scenario, verified_vaa, ticket); + let ( + chain, + _ + ) = register_chain(&mut token_bridge_state, receipt); + + // Check registry. + let expected_contract = + *table::borrow( + state::borrow_emitter_registry(&token_bridge_state), + chain + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let verified_vaa = + parse_and_verify_vaa(scenario, VAA_REGISTER_SAME_CHAIN); + let payload = + governance_message::take_decree( + wormhole::vaa::payload(&verified_vaa) + ); + let cur = cursor::new(payload); + + // Show this payload is attempting to register the same chain ID. + let another_chain = bytes::take_u16_be(&mut cur); + assert!(chain == another_chain, 0); + + let another_contract = external_address::take_bytes(&mut cur); + assert!(another_contract != expected_contract, 0); + + // No more payload to read. + cursor::destroy_empty(cur); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let ticket = register_chain::authorize_governance(&token_bridge_state); + let receipt = + verify_governance_vaa(scenario, verified_vaa, ticket); + + // You shall not pass! + register_chain(&mut token_bridge_state, receipt); + + abort 42 + } +} + + + + diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/governance/upgrade_contract.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/governance/upgrade_contract.move new file mode 100644 index 0000000000..9ac95e13de --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/governance/upgrade_contract.move @@ -0,0 +1,125 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact upgrading the +/// Token Bridge contract to a new build. The procedure to upgrade this contract +/// requires a Programmable Transaction, which includes the following procedure: +/// 1. Load new build. +/// 2. Authorize upgrade. +/// 3. Upgrade. +/// 4. Commit upgrade. +module token_bridge::upgrade_contract { + use iota::object::{ID}; + use iota::package::{UpgradeReceipt, UpgradeTicket}; + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::cursor::{Self}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + + use token_bridge::state::{Self, State}; + + friend token_bridge::migrate; + + /// Digest is all zeros. + const E_DIGEST_ZERO_BYTES: u64 = 0; + + /// Specific governance payload ID (action) to complete upgrading the + /// contract. + const ACTION_UPGRADE_CONTRACT: u8 = 2; + + struct GovernanceWitness has drop {} + + // Event reflecting package upgrade. + struct ContractUpgraded has drop, copy { + old_contract: ID, + new_contract: ID + } + + struct UpgradeContract { + digest: Bytes32 + } + + public fun authorize_governance( + token_bridge_state: &State + ): DecreeTicket { + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(token_bridge_state), + state::governance_contract(token_bridge_state), + state::governance_module(), + ACTION_UPGRADE_CONTRACT + ) + } + + /// Redeem governance VAA to issue an `UpgradeTicket` for the upgrade given + /// a contract upgrade VAA. This governance message is only relevant for Iota + /// because a contract upgrade is only relevant to one particular network + /// (in this case Iota), whose build digest is encoded in this message. + public fun authorize_upgrade( + token_bridge_state: &mut State, + receipt: DecreeReceipt + ): UpgradeTicket { + // current package checking when consuming VAA hashes. This is because + // upgrades are protected by the Iota VM, enforcing the latest package + // is the one performing the upgrade. + let consumed = + state::borrow_mut_consumed_vaas_unchecked(token_bridge_state); + + // And consume. + let payload = governance_message::take_payload(consumed, receipt); + + // Proceed with processing new implementation version. + handle_upgrade_contract(token_bridge_state, payload) + } + + /// Finalize the upgrade that ran to produce the given `receipt`. This + /// method invokes `state::commit_upgrade` which interacts with + /// `iota::package`. + public fun commit_upgrade( + self: &mut State, + receipt: UpgradeReceipt, + ) { + let (old_contract, new_contract) = state::commit_upgrade(self, receipt); + + // Emit an event reflecting package ID change. + iota::event::emit(ContractUpgraded { old_contract, new_contract }); + } + + /// Privileged method only to be used by this module and `migrate` module. + /// + /// During migration, we make sure that the digest equals what we expect by + /// passing in the same VAA used to upgrade the package. + public(friend) fun take_digest(governance_payload: vector): Bytes32 { + // Deserialize the payload as the build digest. + let UpgradeContract { digest } = deserialize(governance_payload); + + digest + } + + fun handle_upgrade_contract( + wormhole_state: &mut State, + payload: vector + ): UpgradeTicket { + state::authorize_upgrade(wormhole_state, take_digest(payload)) + } + + fun deserialize(payload: vector): UpgradeContract { + let cur = cursor::new(payload); + + // This amount cannot be greater than max u64. + let digest = bytes32::take_bytes(&mut cur); + assert!(bytes32::is_nonzero(&digest), E_DIGEST_ZERO_BYTES); + + cursor::destroy_empty(cur); + + UpgradeContract { digest } + } + + #[test_only] + public fun action(): u8 { + ACTION_UPGRADE_CONTRACT + } +} + +#[test_only] +module token_bridge::upgrade_contract_tests { + // TODO +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/messages/asset_meta.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/messages/asset_meta.move new file mode 100644 index 0000000000..df28384cea --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/messages/asset_meta.move @@ -0,0 +1,251 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements serialization and deserialization for asset metadata, +/// which is a specific Wormhole message payload for Token Bridge. +module token_bridge::asset_meta { + use std::string::{Self, String}; + use std::vector::{Self}; + use iota::coin::{Self, CoinMetadata}; + use wormhole::bytes::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + use wormhole::cursor::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::native_asset::{Self}; + + friend token_bridge::attest_token; + friend token_bridge::create_wrapped; + friend token_bridge::wrapped_asset; + + /// Message payload is not `AssetMeta`. + const E_INVALID_PAYLOAD: u64 = 0; + + /// Message identifier. + const PAYLOAD_ID: u8 = 2; + + /// Container that warehouses asset metadata information. This struct is + /// used only by `attest_token` and `create_wrapped` modules. + struct AssetMeta { + /// Address of the token. + token_address: ExternalAddress, + /// Chain ID of the token. + token_chain: u16, + /// Number of decimals of the token. + native_decimals: u8, + /// Symbol of the token (UTF-8). + /// TODO(csongor): maybe turn these into String32s? + symbol: String, + /// Name of the token (UTF-8). + name: String, + } + + + public(friend) fun from_metadata(metadata: &CoinMetadata): AssetMeta { + AssetMeta { + token_address: native_asset::canonical_address(metadata), + token_chain: chain_id(), + native_decimals: coin::get_decimals(metadata), + symbol: string::from_ascii(coin::get_symbol(metadata)), + name: coin::get_name(metadata) + } + } + + #[test_only] + public fun from_metadata_test_only(metadata: &CoinMetadata): AssetMeta { + from_metadata(metadata) + } + + public(friend) fun unpack( + meta: AssetMeta + ): ( + ExternalAddress, + u16, + u8, + String, + String + ) { + let AssetMeta { + token_address, + token_chain, + native_decimals, + symbol, + name + } = meta; + + ( + token_address, + token_chain, + native_decimals, + symbol, + name + ) + } + + + #[test_only] + public fun unpack_test_only( + meta: AssetMeta + ): ( + ExternalAddress, + u16, + u8, + String, + String + ) { + unpack(meta) + } + + public fun token_chain(self: &AssetMeta): u16 { + self.token_chain + } + + public fun token_address(self: &AssetMeta): ExternalAddress { + self.token_address + } + + public(friend) fun serialize(meta: AssetMeta): vector { + let ( + token_address, + token_chain, + native_decimals, + symbol, + name + ) = unpack(meta); + + let buf = vector::empty(); + bytes::push_u8(&mut buf, PAYLOAD_ID); + vector::append(&mut buf, external_address::to_bytes(token_address)); + bytes::push_u16_be(&mut buf, token_chain); + bytes::push_u8(&mut buf, native_decimals); + vector::append( + &mut buf, + bytes32::to_bytes(bytes32::from_utf8(symbol)) + ); + vector::append( + &mut buf, + bytes32::to_bytes(bytes32::from_utf8(name)) + ); + + buf + } + + #[test_only] + public fun serialize_test_only(meta: AssetMeta): vector { + serialize(meta) + } + + public(friend) fun deserialize(buf: vector): AssetMeta { + let cur = cursor::new(buf); + assert!(bytes::take_u8(&mut cur) == PAYLOAD_ID, E_INVALID_PAYLOAD); + let token_address = external_address::take_bytes(&mut cur); + let token_chain = bytes::take_u16_be(&mut cur); + let native_decimals = bytes::take_u8(&mut cur); + let symbol = bytes32::to_utf8(bytes32::take_bytes(&mut cur)); + let name = bytes32::to_utf8(bytes32::take_bytes(&mut cur)); + cursor::destroy_empty(cur); + + AssetMeta { + token_address, + token_chain, + native_decimals, + symbol, + name + } + } + + #[test_only] + public fun deserialize_test_only(buf: vector): AssetMeta { + deserialize(buf) + } + + #[test_only] + public fun new( + token_address: ExternalAddress, + token_chain: u16, + native_decimals: u8, + symbol: String, + name: String, + ): AssetMeta { + AssetMeta { + token_address, + token_chain, + native_decimals, + symbol, + name + } + } + + #[test_only] + public fun native_decimals(self: &AssetMeta): u8 { + self.native_decimals + } + + #[test_only] + public fun symbol(self: &AssetMeta): String { + self.symbol + } + + #[test_only] + public fun name(self: &AssetMeta): String { + self.name + } + + #[test_only] + public fun destroy(token_meta: AssetMeta) { + unpack(token_meta); + } + + #[test_only] + public fun payload_id(): u8 { + PAYLOAD_ID + } +} + +#[test_only] +module token_bridge::asset_meta_tests { + use std::string::{Self}; + use wormhole::external_address::{Self}; + use wormhole::vaa::{Self}; + + use token_bridge::asset_meta::{Self}; + + #[test] + fun test_serialize_deserialize() { + let token_address = external_address::from_address(@0x1122); + let symbol = string::utf8(b"a creative symbol"); + let name = string::utf8(b"a creative name"); + let asset_meta = asset_meta::new( + token_address, //token address + 3, // token chain + 4, //native decimals + symbol, // symbol + name, // name + ); + // Serialize and deserialize TransferWithPayload object. + let se = asset_meta::serialize_test_only(asset_meta); + let de = asset_meta::deserialize_test_only(se); + + // Test that the object fields are unchanged. + assert!(asset_meta::token_chain(&de) == 3, 0); + assert!(asset_meta::token_address(&de) == token_address, 0); + assert!(asset_meta::native_decimals(&de) == 4, 0); + assert!(asset_meta::symbol(&de) == symbol, 0); + assert!(asset_meta::name(&de) == name, 0); + + // Clean up. + asset_meta::destroy(de); + } + + #[test] + fun test_create_wrapped_12() { + use token_bridge::dummy_message::{encoded_asset_meta_vaa_foreign_12}; + + let payload = + vaa::peel_payload_from_vaa(&encoded_asset_meta_vaa_foreign_12()); + + let token_meta = asset_meta::deserialize_test_only(payload); + let serialized = asset_meta::serialize_test_only(token_meta); + assert!(payload == serialized, 0); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/messages/transfer.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/messages/transfer.move new file mode 100644 index 0000000000..190afad9dc --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/messages/transfer.move @@ -0,0 +1,311 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements serialization and deserialization for token transfer +/// with an optional relayer fee. This message is a specific Wormhole message +/// payload for Token Bridge. +/// +/// When this transfer is redeemed, the relayer fee will be subtracted from the +/// transfer amount. If the transaction sender is the same address of the +/// recipient, the recipient will collect the full amount. +/// +/// See `transfer_tokens` and `complete_transfer` modules for more details. +module token_bridge::transfer { + use std::vector::{Self}; + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + + use token_bridge::normalized_amount::{Self, NormalizedAmount}; + + friend token_bridge::complete_transfer; + friend token_bridge::transfer_tokens; + + /// Message payload is not `Transfer`. + const E_INVALID_PAYLOAD: u64 = 0; + + /// Message identifier. + const PAYLOAD_ID: u8 = 1; + + /// Container that warehouses transfer information. This struct is used only + /// by `transfer_tokens` and `complete_transfer` modules. + struct Transfer { + // Amount being transferred. + amount: NormalizedAmount, + // Address of the token. Left-zero-padded if shorter than 32 bytes. + token_address: ExternalAddress, + // Chain ID of the token. + token_chain: u16, + // Address of the recipient. Left-zero-padded if shorter than 32 bytes. + recipient: ExternalAddress, + // Chain ID of the recipient. + recipient_chain: u16, + // Amount of tokens that the user is willing to pay as relayer fee. + // Must be <= amount. + relayer_fee: NormalizedAmount, + } + + /// Create new `Transfer`. + public(friend) fun new( + amount: NormalizedAmount, + token_address: ExternalAddress, + token_chain: u16, + recipient: ExternalAddress, + recipient_chain: u16, + relayer_fee: NormalizedAmount, + ): Transfer { + Transfer { + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee, + } + } + + #[test_only] + public fun new_test_only( + amount: NormalizedAmount, + token_address: ExternalAddress, + token_chain: u16, + recipient: ExternalAddress, + recipient_chain: u16, + relayer_fee: NormalizedAmount, + ): Transfer { + new( + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee + ) + } + + /// Decompose `Transfer` into its members. + public(friend) fun unpack( + transfer: Transfer + ): ( + NormalizedAmount, + ExternalAddress, + u16, + ExternalAddress, + u16, + NormalizedAmount + ) { + let Transfer { + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee, + } = transfer; + + ( + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee + ) + } + + #[test_only] + public fun unpack_test_only( + transfer: Transfer + ): ( + NormalizedAmount, + ExternalAddress, + u16, + ExternalAddress, + u16, + NormalizedAmount + ) { + unpack(transfer) + } + + /// Decode Wormhole message payload as `Transfer`. + public(friend) fun deserialize(buf: vector): Transfer { + let cur = cursor::new(buf); + assert!(bytes::take_u8(&mut cur) == PAYLOAD_ID, E_INVALID_PAYLOAD); + + let amount = normalized_amount::take_bytes(&mut cur); + let token_address = external_address::take_bytes(&mut cur); + let token_chain = bytes::take_u16_be(&mut cur); + let recipient = external_address::take_bytes(&mut cur); + let recipient_chain = bytes::take_u16_be(&mut cur); + let relayer_fee = normalized_amount::take_bytes(&mut cur); + cursor::destroy_empty(cur); + + Transfer { + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee, + } + } + + #[test_only] + public fun deserialize_test_only(buf: vector): Transfer { + deserialize(buf) + } + + /// Encode `Transfer` for Wormhole message payload. + public(friend) fun serialize(transfer: Transfer): vector { + let ( + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee, + ) = unpack(transfer); + + let buf = vector::empty(); + bytes::push_u8(&mut buf, PAYLOAD_ID); + vector::append(&mut buf, normalized_amount::to_bytes(amount)); + vector::append(&mut buf, external_address::to_bytes(token_address)); + bytes::push_u16_be(&mut buf, token_chain); + vector::append(&mut buf, external_address::to_bytes(recipient)); + bytes::push_u16_be(&mut buf, recipient_chain); + vector::append(&mut buf, normalized_amount::to_bytes(relayer_fee)); + + buf + } + + #[test_only] + public fun serialize_test_only(transfer: Transfer): vector { + serialize(transfer) + } + + #[test_only] + public fun amount(self: &Transfer): NormalizedAmount { + self.amount + } + + #[test_only] + public fun raw_amount(self: &Transfer, decimals: u8): u64 { + normalized_amount::to_raw(self.amount, decimals) + } + + #[test_only] + public fun token_address(self: &Transfer): ExternalAddress { + self.token_address + } + + #[test_only] + public fun token_chain(self: &Transfer): u16 { + self.token_chain + } + + #[test_only] + public fun recipient(self: &Transfer): ExternalAddress { + self.recipient + } + + #[test_only] + public fun recipient_as_address(self: &Transfer): address { + external_address::to_address(self.recipient) + } + + #[test_only] + public fun recipient_chain(self: &Transfer): u16 { + self.recipient_chain + } + + #[test_only] + public fun relayer_fee(self: &Transfer): NormalizedAmount { + self.relayer_fee + } + + #[test_only] + public fun raw_relayer_fee(self: &Transfer, decimals: u8): u64 { + normalized_amount::to_raw(self.relayer_fee, decimals) + } + + #[test_only] + public fun destroy(transfer: Transfer) { + unpack(transfer); + } + + #[test_only] + public fun payload_id(): u8 { + PAYLOAD_ID + } +} + +#[test_only] +module token_bridge::transfer_tests { + use std::vector::{Self}; + use wormhole::external_address::{Self}; + + use token_bridge::dummy_message::{Self}; + use token_bridge::transfer::{Self}; + use token_bridge::normalized_amount::{Self}; + + #[test] + fun test_serialize_deserialize() { + let decimals = 8; + let expected_amount = normalized_amount::from_raw(234567890, decimals); + let expected_token_address = external_address::from_address(@0xbeef); + let expected_token_chain = 1; + let expected_recipient = external_address::from_address(@0xcafe); + let expected_recipient_chain = 7; + let expected_relayer_fee = + normalized_amount::from_raw(123456789, decimals); + + let serialized = + transfer::serialize_test_only( + transfer::new_test_only( + expected_amount, + expected_token_address, + expected_token_chain, + expected_recipient, + expected_recipient_chain, + expected_relayer_fee, + ) + ); + assert!(serialized == dummy_message::encoded_transfer(), 0); + + let ( + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee + ) = transfer::unpack_test_only( + transfer::deserialize_test_only(serialized) + ); + assert!(amount == expected_amount, 0); + assert!(token_address == expected_token_address, 0); + assert!(token_chain == expected_token_chain, 0); + assert!(recipient == expected_recipient, 0); + assert!(recipient_chain == expected_recipient_chain, 0); + assert!(relayer_fee == expected_relayer_fee, 0); + } + + #[test] + #[expected_failure(abort_code = transfer::E_INVALID_PAYLOAD)] + fun test_cannot_deserialize_invalid_payload() { + let invalid_payload = dummy_message::encoded_transfer_with_payload(); + + // Show that the first byte is not the expected payload ID. + assert!( + *vector::borrow(&invalid_payload, 0) != transfer::payload_id(), + 0 + ); + + // You shall not pass! + let parsed = transfer::deserialize_test_only(invalid_payload); + + // Clean up. + transfer::destroy(parsed); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/messages/transfer_with_payload.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/messages/transfer_with_payload.move new file mode 100644 index 0000000000..9c00a36385 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/messages/transfer_with_payload.move @@ -0,0 +1,352 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements serialization and deserialization for token transfer +/// with an arbitrary payload. This message is a specific Wormhole message +/// payload for Token Bridge. +/// +/// In order to redeem these types of transfers, one must have an `EmitterCap` +/// and the specified `redeemer` must agree with this capability. +/// +/// See `transfer_tokens_with_payload` and `complete_transfer_with_payload` +/// modules for more details. +module token_bridge::transfer_with_payload { + use std::vector::{Self}; + use iota::object::{Self, ID}; + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + + use token_bridge::normalized_amount::{Self, NormalizedAmount}; + + friend token_bridge::transfer_tokens_with_payload; + + /// Message payload is not `TransferWithPayload`. + const E_INVALID_PAYLOAD: u64 = 0; + + /// Message identifier. + const PAYLOAD_ID: u8 = 3; + + /// Container that warehouses transfer information, including arbitrary + /// payload. + /// + /// NOTE: This struct has `drop` because we do not want to require an + /// integrator receiving transfer information to have to manually destroy. + struct TransferWithPayload has drop { + // Transfer amount. + amount: NormalizedAmount, + // Address of the token. Left-zero-padded if shorter than 32 bytes. + token_address: ExternalAddress, + // Chain ID of the token. + token_chain: u16, + // A.K.A. 32-byte representation of `EmitterCap`. + redeemer: ExternalAddress, + // Chain ID of the redeemer. + redeemer_chain: u16, + // Address of the message sender. + sender: ExternalAddress, + // An arbitrary payload. + payload: vector, + } + + /// Create new `TransferWithPayload` using a Token Bridge integrator's + /// emitter cap ID as the sender. + public(friend) fun new( + sender: ID, + amount: NormalizedAmount, + token_address: ExternalAddress, + token_chain: u16, + redeemer: ExternalAddress, + redeemer_chain: u16, + payload: vector + ): TransferWithPayload { + TransferWithPayload { + amount, + token_address, + token_chain, + redeemer, + redeemer_chain, + sender: external_address::from_id(sender), + payload + } + } + + #[test_only] + public fun new_test_only( + sender: ID, + amount: NormalizedAmount, + token_address: ExternalAddress, + token_chain: u16, + redeemer: ExternalAddress, + redeemer_chain: u16, + payload: vector + ): TransferWithPayload { + new( + sender, + amount, + token_address, + token_chain, + redeemer, + redeemer_chain, + payload + ) + } + + /// Destroy `TransferWithPayload` and take only its payload. + public fun take_payload(transfer: TransferWithPayload): vector { + let TransferWithPayload { + amount: _, + token_address: _, + token_chain: _, + redeemer: _, + redeemer_chain: _, + sender: _, + payload + } = transfer; + + payload + } + + /// Retrieve normalized amount of token transfer. + public fun amount(self: &TransferWithPayload): NormalizedAmount { + self.amount + } + + // Retrieve token's canonical address. + public fun token_address(self: &TransferWithPayload): ExternalAddress { + self.token_address + } + + /// Retrieve token's canonical chain ID. + public fun token_chain(self: &TransferWithPayload): u16 { + self.token_chain + } + + /// Retrieve redeemer. + public fun redeemer(self: &TransferWithPayload): ExternalAddress { + self.redeemer + } + + // Retrieve redeemer as `ID`. + public fun redeemer_id(self: &TransferWithPayload): ID { + object::id_from_bytes(external_address::to_bytes(self.redeemer)) + } + + /// Retrieve target chain for redeemer. + public fun redeemer_chain(self: &TransferWithPayload): u16 { + self.redeemer_chain + } + + /// Retrieve transfer sender. + public fun sender(self: &TransferWithPayload): ExternalAddress { + self.sender + } + + /// Retrieve arbitrary payload. + public fun payload(self: &TransferWithPayload): vector { + self.payload + } + + /// Decode Wormhole message payload as `TransferWithPayload`. + public fun deserialize(transfer: vector): TransferWithPayload { + let cur = cursor::new(transfer); + assert!(bytes::take_u8(&mut cur) == PAYLOAD_ID, E_INVALID_PAYLOAD); + + let amount = normalized_amount::take_bytes(&mut cur); + let token_address = external_address::take_bytes(&mut cur); + let token_chain = bytes::take_u16_be(&mut cur); + let redeemer = external_address::take_bytes(&mut cur); + let redeemer_chain = bytes::take_u16_be(&mut cur); + let sender = external_address::take_bytes(&mut cur); + + TransferWithPayload { + amount, + token_address, + token_chain, + redeemer, + redeemer_chain, + sender, + payload: cursor::take_rest(cur) + } + } + + /// Encode `TransferWithPayload` for Wormhole message payload. + public fun serialize(transfer: TransferWithPayload): vector { + let TransferWithPayload { + amount, + token_address, + token_chain, + redeemer, + redeemer_chain, + sender, + payload + } = transfer; + + let buf = vector::empty(); + bytes::push_u8(&mut buf, PAYLOAD_ID); + bytes::push_u256_be(&mut buf, normalized_amount::to_u256(amount)); + vector::append(&mut buf, external_address::to_bytes(token_address)); + bytes::push_u16_be(&mut buf, token_chain); + vector::append(&mut buf, external_address::to_bytes(redeemer)); + bytes::push_u16_be(&mut buf, redeemer_chain); + vector::append(&mut buf, external_address::to_bytes(sender)); + vector::append(&mut buf, payload); + + buf + } + + #[test_only] + public fun destroy(transfer: TransferWithPayload) { + take_payload(transfer); + } + + #[test_only] + public fun payload_id(): u8 { + PAYLOAD_ID + } +} + +#[test_only] +module token_bridge::transfer_with_payload_tests { + use std::vector::{Self}; + use iota::object::{Self}; + use wormhole::emitter::{Self}; + use wormhole::external_address::{Self}; + + use token_bridge::dummy_message::{Self}; + use token_bridge::normalized_amount::{Self}; + use token_bridge::transfer_with_payload::{Self}; + + #[test] + fun test_serialize() { + let emitter_cap = emitter::dummy(); + let amount = normalized_amount::from_raw(234567890, 8); + let token_address = external_address::from_address(@0xbeef); + let token_chain = 1; + let redeemer = external_address::from_address(@0xcafe); + let redeemer_chain = 7; + let payload = b"All your base are belong to us."; + + let new_transfer = + transfer_with_payload::new_test_only( + object::id(&emitter_cap), + amount, + token_address, + token_chain, + redeemer, + redeemer_chain, + payload + ); + + // Verify getters. + assert!( + transfer_with_payload::amount(&new_transfer) == amount, + 0 + ); + assert!( + transfer_with_payload::token_address(&new_transfer) == token_address, + 0 + ); + assert!( + transfer_with_payload::token_chain(&new_transfer) == token_chain, + 0 + ); + assert!( + transfer_with_payload::redeemer(&new_transfer) == redeemer, + 0 + ); + assert!( + transfer_with_payload::redeemer_chain(&new_transfer) == redeemer_chain, + 0 + ); + let expected_sender = + external_address::from_id(object::id(&emitter_cap)); + assert!( + transfer_with_payload::sender(&new_transfer) == expected_sender, + 0 + ); + assert!( + transfer_with_payload::payload(&new_transfer) == payload, + 0 + ); + + let serialized = transfer_with_payload::serialize(new_transfer); + let expected_serialized = + dummy_message::encoded_transfer_with_payload(); + assert!(serialized == expected_serialized, 0); + + // Clean up. + emitter::destroy_test_only(emitter_cap); + } + + #[test] + fun test_deserialize() { + let expected_amount = normalized_amount::from_raw(234567890, 8); + let expected_token_address = external_address::from_address(@0xbeef); + let expected_token_chain = 1; + let expected_recipient = external_address::from_address(@0xcafe); + let expected_recipient_chain = 7; + let expected_sender = + external_address::from_address( + @0x381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f409 + ); + let expected_payload = b"All your base are belong to us."; + + let parsed = + transfer_with_payload::deserialize( + dummy_message::encoded_transfer_with_payload() + ); + + // Verify getters. + assert!( + transfer_with_payload::amount(&parsed) == expected_amount, + 0 + ); + assert!( + transfer_with_payload::token_address(&parsed) == expected_token_address, + 0 + ); + assert!( + transfer_with_payload::token_chain(&parsed) == expected_token_chain, + 0 + ); + assert!( + transfer_with_payload::redeemer(&parsed) == expected_recipient, + 0 + ); + assert!( + transfer_with_payload::redeemer_chain(&parsed) == expected_recipient_chain, + 0 + ); + assert!( + transfer_with_payload::sender(&parsed) == expected_sender, + 0 + ); + assert!( + transfer_with_payload::payload(&parsed) == expected_payload, + 0 + ); + + let payload = transfer_with_payload::take_payload(parsed); + assert!(payload == expected_payload, 0); + } + + #[test] + #[expected_failure(abort_code = transfer_with_payload::E_INVALID_PAYLOAD)] + fun test_cannot_deserialize_invalid_payload() { + let invalid_payload = token_bridge::dummy_message::encoded_transfer(); + + // Show that the first byte is not the expected payload ID. + assert!( + *vector::borrow(&invalid_payload, 0) != transfer_with_payload::payload_id(), + 0 + ); + + // You shall not pass! + let parsed = transfer_with_payload::deserialize(invalid_payload); + + // Clean up. + transfer_with_payload::destroy(parsed); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/migrate.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/migrate.move new file mode 100644 index 0000000000..b8d62bcab8 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/migrate.move @@ -0,0 +1,216 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a public method intended to be called after an +/// upgrade has been committed. The purpose is to add one-off migration logic +/// that would alter Token Bridge `State`. +/// +/// Included in migration is the ability to ensure that breaking changes for +/// any of Token Bridge's methods by enforcing the current build version as +/// their required minimum version. +module token_bridge::migrate { + use iota::object::{ID}; + use wormhole::governance_message::{Self, DecreeReceipt}; + + use token_bridge::state::{Self, State}; + use token_bridge::upgrade_contract::{Self}; + + /// Event reflecting when `migrate` is successfully executed. + struct MigrateComplete has drop, copy { + package: ID + } + + /// Execute migration logic. See `token_bridge::migrate` description for + /// more info. + public fun migrate( + token_bridge_state: &mut State, + receipt: DecreeReceipt + ) { + state::migrate__v__0_2_0(token_bridge_state); + + // Perform standard migrate. + handle_migrate(token_bridge_state, receipt); + + //////////////////////////////////////////////////////////////////////// + // + // NOTE: Put any one-off migration logic here. + // + // Most upgrades likely won't need to do anything, in which case the + // rest of this function's body may be empty. Make sure to delete it + // after the migration has gone through successfully. + // + // WARNING: The migration does *not* proceed atomically with the + // upgrade (as they are done in separate transactions). + // If the nature of this migration absolutely requires the migration to + // happen before certain other functionality is available, then guard + // that functionality with the `assert!` from above. + // + //////////////////////////////////////////////////////////////////////// + + //////////////////////////////////////////////////////////////////////// + } + + fun handle_migrate( + token_bridge_state: &mut State, + receipt: DecreeReceipt + ) { + // Update the version first. + // + // See `version_control` module for hard-coded configuration. + state::migrate_version(token_bridge_state); + + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // Check if build digest is the current one. + let digest = + upgrade_contract::take_digest( + governance_message::payload(&receipt) + ); + state::assert_authorized_digest( + &latest_only, + token_bridge_state, + digest + ); + governance_message::destroy(receipt); + + // Finally emit an event reflecting a successful migrate. + let package = state::current_package(&latest_only, token_bridge_state); + iota::event::emit(MigrateComplete { package }); + } + + #[test_only] + public fun set_up_migrate(token_bridge_state: &mut State) { + state::reverse_migrate__v__dummy(token_bridge_state); + } +} + +#[test_only] +module token_bridge::migrate_tests { + use iota::test_scenario::{Self}; + use wormhole::wormhole_scenario::{ + parse_and_verify_vaa, + verify_governance_vaa + }; + + use token_bridge::state::{Self}; + use token_bridge::upgrade_contract::{Self}; + use token_bridge::token_bridge_scenario::{ + person, + return_state, + set_up_wormhole_and_token_bridge, + take_state, + upgrade_token_bridge + }; + + const UPGRADE_VAA: vector = + x"010000000001005b18d7710c442414435162dc2b46a421c3018a7ff03290eff112a828b7927e4a6a624174cb8385210f4684ac2dbde6e01e4046218f7f245af53e85c97a48e21a0100bc614e0000000000010000000000000000000000000000000000000000000000000000000000000004000000000000000101000000000000000000000000000000000000000000546f6b656e42726964676502001500000000000000000000000000000000000000000000006e6577206275696c64"; + + #[test] + fun test_migrate() { + use token_bridge::migrate::{migrate}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole. + let wormhole_message_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + // Upgrade (digest is just b"new build") for testing purposes. + upgrade_token_bridge(scenario); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + // Set up migrate (which prepares this package to be the same state as + // a previous release). + token_bridge::migrate::set_up_migrate(&mut token_bridge_state); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + let verified_vaa = parse_and_verify_vaa(scenario, UPGRADE_VAA); + let ticket = + upgrade_contract::authorize_governance(&token_bridge_state); + let receipt = + verify_governance_vaa(scenario, verified_vaa, ticket); + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + migrate(&mut token_bridge_state, receipt); + + // Make sure we emitted an event. + let effects = test_scenario::next_tx(scenario, user); + assert!(test_scenario::num_user_events(&effects) == 1, 0); + + // Clean up. + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_INCORRECT_OLD_VERSION)] + /// ^ This expected error may change depending on the migration. In most + /// cases, this will abort with `wormhole::package_utils::E_INCORRECT_OLD_VERSION`. + fun test_cannot_migrate_again() { + use token_bridge::migrate::{migrate}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole. + let wormhole_message_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + // Upgrade (digest is just b"new build") for testing purposes. + upgrade_token_bridge(scenario); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + // Set up migrate (which prepares this package to be the same state as + // a previous release). + token_bridge::migrate::set_up_migrate(&mut token_bridge_state); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + let verified_vaa = parse_and_verify_vaa(scenario, UPGRADE_VAA); + let ticket = + upgrade_contract::authorize_governance(&token_bridge_state); + let receipt = + verify_governance_vaa(scenario, verified_vaa, ticket); + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + migrate(&mut token_bridge_state, receipt); + + // Make sure we emitted an event. + let effects = test_scenario::next_tx(scenario, user); + assert!(test_scenario::num_user_events(&effects) == 1, 0); + + let verified_vaa = parse_and_verify_vaa(scenario, UPGRADE_VAA); + let ticket = + upgrade_contract::authorize_governance(&token_bridge_state); + let receipt = + verify_governance_vaa(scenario, verified_vaa, ticket); + // You shall not pass! + migrate(&mut token_bridge_state, receipt); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/resources/native_asset.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/resources/native_asset.move new file mode 100644 index 0000000000..89898868da --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/resources/native_asset.move @@ -0,0 +1,220 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type that keeps track of info relating to +/// assets (coin types) native to Iota. Token Bridge takes custody of these +/// assets when someone invokes a token transfer outbound. Likewise, Token +/// Bridge releases some of its balance from its custody of when someone redeems +/// an inbound token transfer intended for Iota. +/// +/// See `token_registry` module for more details. +module token_bridge::native_asset { + use iota::balance::{Self, Balance}; + use iota::coin::{Self, CoinMetadata}; + use iota::object::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + use wormhole::state::{chain_id}; + + friend token_bridge::complete_transfer; + friend token_bridge::token_registry; + friend token_bridge::transfer_tokens; + + /// Container for storing canonical token address and custodied `Balance`. + struct NativeAsset has store { + custody: Balance, + token_address: ExternalAddress, + decimals: u8 + } + + /// Token Bridge identifies native assets using `CoinMetadata` object `ID`. + /// This method converts this `ID` to `ExternalAddress`. + public fun canonical_address( + metadata: &CoinMetadata + ): ExternalAddress { + external_address::from_id(object::id(metadata)) + } + + /// Create new `NativeAsset`. + /// + /// NOTE: The canonical token address is determined by the coin metadata's + /// object ID. + public(friend) fun new(metadata: &CoinMetadata): NativeAsset { + NativeAsset { + custody: balance::zero(), + token_address: canonical_address(metadata), + decimals: coin::get_decimals(metadata) + } + } + + #[test_only] + public fun new_test_only(metadata: &CoinMetadata): NativeAsset { + new(metadata) + } + + /// Retrieve canonical token address. + public fun token_address(self: &NativeAsset): ExternalAddress { + self.token_address + } + + /// Retrieve decimals, which originated from `CoinMetadata`. + public fun decimals(self: &NativeAsset): u8 { + self.decimals + } + + /// Retrieve custodied `Balance` value. + public fun custody(self: &NativeAsset): u64 { + balance::value(&self.custody) + } + + /// Retrieve canonical token chain ID (Iota's) and token address. + public fun canonical_info( + self: &NativeAsset + ): (u16, ExternalAddress) { + (chain_id(), self.token_address) + } + + /// Deposit a given `Balance`. `Balance` originates from an outbound token + /// transfer for a native asset. + /// + /// See `transfer_tokens` module for more info. + public(friend) fun deposit( + self: &mut NativeAsset, + deposited: Balance + ) { + balance::join(&mut self.custody, deposited); + } + + #[test_only] + public fun deposit_test_only( + self: &mut NativeAsset, + deposited: Balance + ) { + deposit(self, deposited) + } + + /// Withdraw a given amount from custody. This amount is determiend by an + /// inbound token transfer payload for a native asset. + /// + /// See `complete_transfer` module for more info. + public(friend) fun withdraw( + self: &mut NativeAsset, + amount: u64 + ): Balance { + balance::split(&mut self.custody, amount) + } + + #[test_only] + public fun withdraw_test_only( + self: &mut NativeAsset, + amount: u64 + ): Balance { + withdraw(self, amount) + } + + #[test_only] + public fun destroy(asset: NativeAsset) { + let NativeAsset { + custody, + token_address: _, + decimals: _ + } = asset; + balance::destroy_for_testing(custody); + } +} + +#[test_only] +module token_bridge::native_asset_tests { + use iota::balance::{Self}; + use iota::coin::{Self}; + use iota::object::{Self}; + use iota::test_scenario::{Self}; + use wormhole::external_address::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::native_asset::{Self}; + use token_bridge::token_bridge_scenario::{person}; + + #[test] + /// In this test, we exercise all the functionalities of a native asset + /// object, including new, deposit, withdraw, to_token_info, as well as + /// getting fields token_address, decimals, balance. + fun test_native_asset() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Publish coin. + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let coin_meta = coin_native_10::take_metadata(scenario); + + // Make new. + let asset = native_asset::new_test_only(&coin_meta); + + // Assert token address and decimals are correct. + let expected_token_address = + external_address::from_id(object::id(&coin_meta)); + assert!( + native_asset::token_address(&asset) == expected_token_address, + 0 + ); + assert!( + native_asset::decimals(&asset) == coin::get_decimals(&coin_meta), + 0 + ); + assert!(native_asset::custody(&asset) == 0, 0); + + // deposit some coins into the NativeAsset coin custody + let deposit_amount = 1000; + let (i, n) = (0, 8); + while (i < n) { + native_asset::deposit_test_only( + &mut asset, + balance::create_for_testing( + deposit_amount + ) + ); + i = i + 1; + }; + let total_deposited = n * deposit_amount; + assert!(native_asset::custody(&asset) == total_deposited, 0); + + let withdraw_amount = 690; + let total_withdrawn = balance::zero(); + let i = 0; + while (i < n) { + let withdrawn = native_asset::withdraw_test_only( + &mut asset, + withdraw_amount + ); + assert!(balance::value(&withdrawn) == withdraw_amount, 0); + balance::join(&mut total_withdrawn, withdrawn); + i = i + 1; + }; + + // convert to token info and assert convrsion is correct + let ( + token_chain, + token_address + ) = native_asset::canonical_info(&asset); + + assert!(token_chain == chain_id(), 0); + assert!(token_address == expected_token_address, 0); + + // check that updated balance is correct + let expected_remaining = total_deposited - n * withdraw_amount; + let remaining = native_asset::custody(&asset); + assert!(remaining == expected_remaining, 0); + + // Clean up. + coin_native_10::return_metadata(coin_meta); + balance::destroy_for_testing(total_withdrawn); + native_asset::destroy(asset); + + // Done. + test_scenario::end(my_scenario); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/resources/token_registry.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/resources/token_registry.move new file mode 100644 index 0000000000..1a299ec40f --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/resources/token_registry.move @@ -0,0 +1,784 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type that keeps track of both native and +/// wrapped assets via dynamic fields. These dynamic fields are keyed off using +/// coin types. This registry lives in `State`. +/// +/// See `state` module for more details. +module token_bridge::token_registry { + use std::ascii::{String}; + use std::type_name::{Self}; + use iota::coin::{TreasuryCap, CoinMetadata}; + use iota::dynamic_field::{Self}; + use iota::object::{Self, UID}; + use iota::package::{UpgradeCap}; + use iota::table::{Self, Table}; + use iota::tx_context::{TxContext}; + use wormhole::external_address::{Self, ExternalAddress}; + + use token_bridge::asset_meta::{Self, AssetMeta}; + use token_bridge::native_asset::{Self, NativeAsset}; + use token_bridge::wrapped_asset::{Self, WrappedAsset}; + + friend token_bridge::attest_token; + friend token_bridge::complete_transfer; + friend token_bridge::create_wrapped; + friend token_bridge::state; + friend token_bridge::transfer_tokens; + + /// Asset is not registered yet. + const E_UNREGISTERED: u64 = 0; + /// Cannot register wrapped asset with same canonical token info. + const E_ALREADY_WRAPPED: u64 = 1; + + /// This container is used to store native and wrapped assets of coin type + /// as dynamic fields under its `UID`. It also uses a mechanism to generate + /// arbitrary token addresses for native assets. + struct TokenRegistry has key, store { + id: UID, + num_wrapped: u64, + num_native: u64, + coin_types: Table + } + + /// Container to provide convenient checking of whether an asset is wrapped + /// or native. `VerifiedAsset` can only be created either by passing in a + /// resource with `CoinType` or by verifying input token info against the + /// canonical info that exists in `TokenRegistry`. + /// + /// NOTE: This container can be dropped after it was created. + struct VerifiedAsset has drop { + is_wrapped: bool, + chain: u16, + addr: ExternalAddress, + coin_decimals: u8 + } + + /// Wrapper of coin type to act as dynamic field key. + struct Key has copy, drop, store {} + + /// This struct is not used for anything within the contract. It exists + /// purely for someone with an RPC query to be able to fetch the type name + /// of coin type as a string via `TokenRegistry`. + struct CoinTypeKey has drop, copy, store { + chain: u16, + addr: vector + } + + /// Create new `TokenRegistry`. + /// + /// See `setup` module for more info. + public(friend) fun new(ctx: &mut TxContext): TokenRegistry { + TokenRegistry { + id: object::new(ctx), + num_wrapped: 0, + num_native: 0, + coin_types: table::new(ctx) + } + } + + #[test_only] + public fun new_test_only(ctx: &mut TxContext): TokenRegistry { + new(ctx) + } + + /// Determine whether a particular coin type is registered. + public fun has(self: &TokenRegistry): bool { + dynamic_field::exists_(&self.id, Key {}) + } + + public fun assert_has(self: &TokenRegistry) { + assert!(has(self), E_UNREGISTERED); + } + + public fun verified_asset( + self: &TokenRegistry + ): VerifiedAsset { + // We check specifically whether `CoinType` is associated with a dynamic + // field for `WrappedAsset`. This boolean will be used as the underlying + // value for `VerifiedAsset`. + let is_wrapped = + dynamic_field::exists_with_type, WrappedAsset>( + &self.id, + Key {} + ); + if (is_wrapped) { + let asset = borrow_wrapped(self); + let (chain, addr) = wrapped_asset::canonical_info(asset); + let coin_decimals = wrapped_asset::decimals(asset); + + VerifiedAsset { is_wrapped, chain, addr, coin_decimals } + } else { + let asset = borrow_native(self); + let (chain, addr) = native_asset::canonical_info(asset); + let coin_decimals = native_asset::decimals(asset); + + VerifiedAsset { is_wrapped, chain, addr, coin_decimals } + } + } + + /// Determine whether a given `CoinType` is a wrapped asset. + public fun is_wrapped(verified: &VerifiedAsset): bool { + verified.is_wrapped + } + + /// Retrieve canonical token chain ID from `VerifiedAsset`. + public fun token_chain( + verified: &VerifiedAsset + ): u16 { + verified.chain + } + + /// Retrieve canonical token address from `VerifiedAsset`. + public fun token_address( + verified: &VerifiedAsset + ): ExternalAddress { + verified.addr + } + + /// Retrieve decimals for a `VerifiedAsset`. + public fun coin_decimals( + verified: &VerifiedAsset + ): u8 { + verified.coin_decimals + } + + /// Add a new wrapped asset to the registry and return the canonical token + /// address. + /// + /// See `state` module for more info. + public(friend) fun add_new_wrapped( + self: &mut TokenRegistry, + token_meta: AssetMeta, + coin_meta: &mut CoinMetadata, + treasury_cap: TreasuryCap, + upgrade_cap: UpgradeCap + ): ExternalAddress { + // Grab canonical token info. + let token_chain = asset_meta::token_chain(&token_meta); + let token_addr = asset_meta::token_address(&token_meta); + + let coin_types = &mut self.coin_types; + let key = + CoinTypeKey { + chain: token_chain, + addr: external_address::to_bytes(token_addr) + }; + // We need to make sure that the canonical token info has not been + // created for another coin type. This can happen if asset metadata + // is attested again from a foreign chain and another coin type is + // published using its VAA. + assert!(!table::contains(coin_types, key), E_ALREADY_WRAPPED); + + // Now add the coin type. + table::add( + coin_types, + key, + type_name::into_string(type_name::get()) + ); + + // NOTE: We do not assert that the coin type has not already been + // registered using !has(self) because `wrapped_asset::new` + // consumes `TreasuryCap`. This `TreasuryCap` is only created once for a particuar + // coin type via `create_wrapped::prepare_registration`. Because the + // `TreasuryCap` is globally unique and can only be created once, there is no + // risk that `add_new_wrapped` can be called again on the same coin + // type. + let asset = + wrapped_asset::new( + token_meta, + coin_meta, + treasury_cap, + upgrade_cap + ); + dynamic_field::add(&mut self.id, Key {}, asset); + self.num_wrapped = self.num_wrapped + 1; + + token_addr + } + + #[test_only] + public fun add_new_wrapped_test_only( + self: &mut TokenRegistry, + token_meta: AssetMeta, + coin_meta: &mut CoinMetadata, + treasury_cap: TreasuryCap, + ctx: &mut TxContext + ): ExternalAddress { + add_new_wrapped( + self, + token_meta, + coin_meta, + treasury_cap, + iota::package::test_publish( + object::id_from_address(@token_bridge), + ctx + ) + ) + } + + /// Add a new native asset to the registry and return the canonical token + /// address. + /// + /// NOTE: This method does not verify if `CoinType` is already in the + /// registry because `attest_token` already takes care of this check. If + /// This method were to be called on an already-registered asset, this + /// will throw with an error from `iota::dynamic_field` reflectina duplicate + /// field. + /// + /// See `attest_token` module for more info. + public(friend) fun add_new_native( + self: &mut TokenRegistry, + metadata: &CoinMetadata, + ): ExternalAddress { + // Create new native asset. + let asset = native_asset::new(metadata); + let token_addr = native_asset::token_address(&asset); + + // Add to registry. + dynamic_field::add(&mut self.id, Key {}, asset); + self.num_native = self.num_native + 1; + + // Now add the coin type. + table::add( + &mut self.coin_types, + CoinTypeKey { + chain: wormhole::state::chain_id(), + addr: external_address::to_bytes(token_addr) + }, + type_name::into_string(type_name::get()) + ); + + // Return the token address. + token_addr + } + + #[test_only] + public fun add_new_native_test_only( + self: &mut TokenRegistry, + metadata: &CoinMetadata + ): ExternalAddress { + add_new_native(self, metadata) + } + + public fun borrow_wrapped( + self: &TokenRegistry + ): &WrappedAsset { + dynamic_field::borrow(&self.id, Key {}) + } + + public(friend) fun borrow_mut_wrapped( + self: &mut TokenRegistry + ): &mut WrappedAsset { + dynamic_field::borrow_mut(&mut self.id, Key {}) + } + + #[test_only] + public fun borrow_mut_wrapped_test_only( + self: &mut TokenRegistry + ): &mut WrappedAsset { + borrow_mut_wrapped(self) + } + + public fun borrow_native( + self: &TokenRegistry + ): &NativeAsset { + dynamic_field::borrow(&self.id, Key {}) + } + + public(friend) fun borrow_mut_native( + self: &mut TokenRegistry + ): &mut NativeAsset { + dynamic_field::borrow_mut(&mut self.id, Key {}) + } + + #[test_only] + public fun borrow_mut_native_test_only( + self: &mut TokenRegistry + ): &mut NativeAsset { + borrow_mut_native(self) + } + + #[test_only] + public fun num_native(self: &TokenRegistry): u64 { + self.num_native + } + + #[test_only] + public fun num_wrapped(self: &TokenRegistry): u64 { + self.num_wrapped + } + + #[test_only] + public fun destroy(registry: TokenRegistry) { + let TokenRegistry { + id, + num_wrapped: _, + num_native: _, + coin_types + } = registry; + object::delete(id); + table::drop(coin_types); + } + + #[test_only] + public fun coin_type_for( + self: &TokenRegistry, + chain: u16, + addr: vector + ): String { + *table::borrow(&self.coin_types, CoinTypeKey { chain, addr }) + } +} + +// In this test, we exercise the various functionalities of TokenRegistry, +// including registering native and wrapped coins via add_new_native, and +// add_new_wrapped, minting/burning/depositing/withdrawing said tokens, and also +// storing metadata about the tokens. +#[test_only] +module token_bridge::token_registry_tests { + use std::type_name::{Self}; + use iota::balance::{Self}; + use iota::coin::{CoinMetadata}; + use iota::test_scenario::{Self}; + use wormhole::external_address::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::asset_meta::{Self}; + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::coin_wrapped_7::{Self, COIN_WRAPPED_7}; + use token_bridge::native_asset::{Self}; + use token_bridge::token_registry::{Self}; + use token_bridge::token_bridge_scenario::{person}; + use token_bridge::wrapped_asset::{Self}; + + struct SCAM_COIN has drop {} + + #[test] + fun test_registered_tokens_native() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize new coin. + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Initialize new token registry. + let registry = + token_registry::new_test_only(test_scenario::ctx(scenario)); + + // Check initial state. + assert!(token_registry::num_native(®istry) == 0, 0); + assert!(token_registry::num_wrapped(®istry) == 0, 0); + + // Register native asset. + let coin_meta = coin_native_10::take_metadata(scenario); + let token_address = + token_registry::add_new_native_test_only( + &mut registry, + &coin_meta, + ); + let expected_token_address = + native_asset::canonical_address(&coin_meta); + assert!(token_address == expected_token_address, 0); + + // mint some native coins, then deposit them into the token registry + let deposit_amount = 69; + let (i, n) = (0, 8); + while (i < n) { + native_asset::deposit_test_only( + token_registry::borrow_mut_native_test_only( + &mut registry, + ), + balance::create_for_testing( + deposit_amount + ) + ); + i = i + 1; + }; + let total_deposited = n * deposit_amount; + { + let asset = + token_registry::borrow_native(®istry); + assert!(native_asset::custody(asset) == total_deposited, 0); + }; + + // Withdraw and check balances. + let withdraw_amount = 420; + let withdrawn = + native_asset::withdraw_test_only( + token_registry::borrow_mut_native_test_only( + &mut registry + ), + withdraw_amount + ); + assert!(balance::value(&withdrawn) == withdraw_amount, 0); + balance::destroy_for_testing(withdrawn); + + let expected_remaining = total_deposited - withdraw_amount; + { + let asset = + token_registry::borrow_native(®istry); + assert!(native_asset::custody(asset) == expected_remaining, 0); + }; + + // Verify registry values. + assert!(token_registry::num_native(®istry) == 1, 0); + assert!(token_registry::num_wrapped(®istry) == 0, 0); + + let verified = token_registry::verified_asset(®istry); + assert!(!token_registry::is_wrapped(&verified), 0); + assert!(token_registry::coin_decimals(&verified) == 10, 0); + assert!(token_registry::token_chain(&verified) == chain_id(), 0); + assert!( + token_registry::token_address(&verified) == expected_token_address, + 0 + ); + + // Check coin type. + let coin_type = + token_registry::coin_type_for( + ®istry, + token_registry::token_chain(&verified), + external_address::to_bytes( + token_registry::token_address(&verified) + ) + ); + assert!( + coin_type == type_name::into_string(type_name::get()), + 0 + ); + + // Clean up. + token_registry::destroy(registry); + coin_native_10::return_metadata(coin_meta); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_registered_tokens_wrapped() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize new coin. + let treasury_cap = + coin_wrapped_7::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Initialize new token registry. + let registry = + token_registry::new_test_only(test_scenario::ctx(scenario)); + + // Check initial state. + assert!(token_registry::num_wrapped(®istry) == 0, 0); + assert!(token_registry::num_native(®istry) == 0, 0); + + let coin_meta = test_scenario::take_shared>(scenario); + + // Register wrapped asset. + let wrapped_token_meta = coin_wrapped_7::token_meta(); + token_registry::add_new_wrapped_test_only( + &mut registry, + wrapped_token_meta, + &mut coin_meta, + treasury_cap, + test_scenario::ctx(scenario) + ); + + test_scenario::return_shared(coin_meta); + + // Mint wrapped coin via `WrappedAsset` several times. + let mint_amount = 420; + let total_minted = balance::zero(); + let (i, n) = (0, 8); + while (i < n) { + let minted = + wrapped_asset::mint_test_only( + token_registry::borrow_mut_wrapped_test_only( + &mut registry, + ), + mint_amount + ); + assert!(balance::value(&minted) == mint_amount, 0); + balance::join(&mut total_minted, minted); + i = i + 1; + }; + + let total_supply = + wrapped_asset::total_supply( + token_registry::borrow_wrapped( + ®istry + ) + ); + assert!(total_supply == balance::value(&total_minted), 0); + + // withdraw, check value, and re-deposit native coins into registry + let burn_amount = 69; + let burned = + wrapped_asset::burn_test_only( + token_registry::borrow_mut_wrapped_test_only(&mut registry), + balance::split(&mut total_minted, burn_amount) + ); + assert!(burned == burn_amount, 0); + + let expected_remaining = total_supply - burn_amount; + let remaining = + wrapped_asset::total_supply( + token_registry::borrow_wrapped( + ®istry + ) + ); + assert!(remaining == expected_remaining, 0); + balance::destroy_for_testing(total_minted); + + // Verify registry values. + assert!(token_registry::num_wrapped(®istry) == 1, 0); + assert!(token_registry::num_native(®istry) == 0, 0); + + + let verified = token_registry::verified_asset(®istry); + assert!(token_registry::is_wrapped(&verified), 0); + assert!(token_registry::coin_decimals(&verified) == 7, 0); + + let wrapped_token_meta = coin_wrapped_7::token_meta(); + assert!( + token_registry::token_chain(&verified) == asset_meta::token_chain(&wrapped_token_meta), + 0 + ); + assert!( + token_registry::token_address(&verified) == asset_meta::token_address(&wrapped_token_meta), + 0 + ); + + // Check coin type. + let coin_type = + token_registry::coin_type_for( + ®istry, + token_registry::token_chain(&verified), + external_address::to_bytes( + token_registry::token_address(&verified) + ) + ); + assert!( + coin_type == type_name::into_string(type_name::get()), + 0 + ); + + + // Clean up. + token_registry::destroy(registry); + asset_meta::destroy(wrapped_token_meta); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = iota::dynamic_field::EFieldAlreadyExists)] + /// In this negative test case, we try to register a native token twice. + fun test_cannot_add_new_native_again() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize new coin. + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Initialize new token registry. + let registry = + token_registry::new_test_only(test_scenario::ctx(scenario)); + + let coin_meta = coin_native_10::take_metadata(scenario); + + // Add new native asset. + token_registry::add_new_native_test_only( + &mut registry, + &coin_meta + ); + + // You shall not pass! + // + // NOTE: We don't have a custom error for this. This will trigger a + // `iota::dynamic_field` error. + token_registry::add_new_native_test_only( + &mut registry, + &coin_meta + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = iota::dynamic_field::EFieldTypeMismatch)] + // In this negative test case, we attempt to deposit a wrapped token into + // a TokenRegistry object, resulting in failure. A wrapped coin can + // only be minted and burned, not deposited. + fun test_cannot_deposit_wrapped_asset() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let treasury_cap = + coin_wrapped_7::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Initialize new token registry. + let registry = + token_registry::new_test_only(test_scenario::ctx(scenario)); + + let coin_meta = test_scenario::take_shared>(scenario); + + token_registry::add_new_wrapped_test_only( + &mut registry, + coin_wrapped_7::token_meta(), + &mut coin_meta, + treasury_cap, + test_scenario::ctx(scenario) + ); + + test_scenario::return_shared(coin_meta); + + // Mint some wrapped coins and attempt to deposit balance. + let minted = + wrapped_asset::mint_test_only( + token_registry::borrow_mut_wrapped_test_only( + &mut registry + ), + 420420420 + ); + + let verified = token_registry::verified_asset(®istry); + assert!(token_registry::is_wrapped(&verified), 0); + + // You shall not pass! + // + // NOTE: We don't have a custom error for this. This will trigger a + // `iota::dynamic_field` error. + native_asset::deposit_test_only( + token_registry::borrow_mut_native_test_only( + &mut registry + ), + minted + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = iota::dynamic_field::EFieldTypeMismatch)] + // In this negative test case, we attempt to deposit a wrapped token into + // a TokenRegistry object, resulting in failure. A wrapped coin can + // only be minted and burned, not deposited. + fun test_cannot_mint_native_asset() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Initialize new token registry. + let registry = + token_registry::new_test_only(test_scenario::ctx(scenario)); + + let coin_meta = coin_native_10::take_metadata(scenario); + token_registry::add_new_native_test_only( + &mut registry, + &coin_meta + ); + + // Show that this asset is not wrapped. + let verified = token_registry::verified_asset(®istry); + assert!(!token_registry::is_wrapped(&verified), 0); + + // You shall not pass! + // + // NOTE: We don't have a custom error for this. This will trigger a + // `iota::dynamic_field` error. + let minted = + wrapped_asset::mint_test_only( + token_registry::borrow_mut_wrapped_test_only( + &mut registry + ), + 420 + ); + + // Clean up. + balance::destroy_for_testing(minted); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = token_registry::E_ALREADY_WRAPPED)] + fun test_cannot_add_new_wrapped_with_same_canonical_info() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize new coin. + let treasury_cap = + coin_wrapped_7::init_and_take_treasury_cap( + scenario, + caller + ); + + // Initialize other coin + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Initialize new token registry. + let registry = + token_registry::new_test_only(test_scenario::ctx(scenario)); + + let coin_meta = test_scenario::take_shared>(scenario); + + // Register wrapped asset. + token_registry::add_new_wrapped_test_only( + &mut registry, + coin_wrapped_7::token_meta(), + &mut coin_meta, + treasury_cap, + test_scenario::ctx(scenario) + ); + + test_scenario::return_shared(coin_meta); + + let coin_meta = coin_native_10::take_metadata(scenario); + let treasury_cap = coin_native_10::take_treasury_cap(scenario); + + // You shall not pass! + token_registry::add_new_wrapped_test_only( + &mut registry, + coin_wrapped_7::token_meta(), + &mut coin_meta, + treasury_cap, + test_scenario::ctx(scenario) + ); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/resources/wrapped_asset.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/resources/wrapped_asset.move new file mode 100644 index 0000000000..4e60f21995 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/resources/wrapped_asset.move @@ -0,0 +1,806 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements two custom types relating to Token Bridge wrapped +/// assets. These assets have been attested from foreign networks, whose +/// metadata is stored in `ForeignInfo`. The Token Bridge contract is the +/// only authority that can mint and burn these assets via `Supply`. +/// +/// See `create_wrapped` and 'token_registry' modules for more details. +module token_bridge::wrapped_asset { + use std::string::{String}; + use iota::balance::{Self, Balance}; + use iota::coin::{Self, TreasuryCap, CoinMetadata}; + use iota::package::{Self, UpgradeCap}; + use wormhole::external_address::{ExternalAddress}; + use wormhole::state::{chain_id}; + + use token_bridge::string_utils; + use token_bridge::asset_meta::{Self, AssetMeta}; + use token_bridge::normalized_amount::{cap_decimals}; + + friend token_bridge::complete_transfer; + friend token_bridge::create_wrapped; + friend token_bridge::token_registry; + friend token_bridge::transfer_tokens; + + /// Token chain ID matching Iota's are not allowed. + const E_SUI_CHAIN: u64 = 0; + /// Canonical token info does match `AssetMeta` payload. + const E_ASSET_META_MISMATCH: u64 = 1; + /// Coin decimals don't match the VAA. + const E_DECIMALS_MISMATCH: u64 = 2; + + /// Container storing foreign asset info. + struct ForeignInfo has store { + token_chain: u16, + token_address: ExternalAddress, + native_decimals: u8, + symbol: String + } + + /// Container managing `ForeignInfo` and `TreasuryCap` for a wrapped asset + /// coin type. + struct WrappedAsset has store { + info: ForeignInfo, + treasury_cap: TreasuryCap, + decimals: u8, + upgrade_cap: UpgradeCap + } + + /// Create new `WrappedAsset`. + /// + /// See `token_registry` module for more info. + public(friend) fun new( + token_meta: AssetMeta, + coin_meta: &mut CoinMetadata, + treasury_cap: TreasuryCap, + upgrade_cap: UpgradeCap + ): WrappedAsset { + // Verify that the upgrade cap is from the same package as coin type. + // This cap should not have been modified prior to creating this asset + // (i.e. should have the default upgrade policy and build version == 1). + wormhole::package_utils::assert_package_upgrade_cap( + &upgrade_cap, + package::compatible_policy(), + 1 + ); + + let ( + token_address, + token_chain, + native_decimals, + symbol, + name + ) = asset_meta::unpack(token_meta); + + // Protect against adding `AssetMeta` which has Iota's chain ID. + assert!(token_chain != chain_id(), E_SUI_CHAIN); + + // Set metadata. + coin::update_name(&treasury_cap, coin_meta, name); + coin::update_symbol(&treasury_cap, coin_meta, string_utils::to_ascii(&symbol)); + + let decimals = cap_decimals(native_decimals); + + // Ensure that the `C` type has the right number of decimals. This is + // the only field in the coinmeta that cannot be changed after the fact, + // so we expect to receive one that already has the correct decimals + // set. + assert!(decimals == coin::get_decimals(coin_meta), E_DECIMALS_MISMATCH); + + let info = + ForeignInfo { + token_address, + token_chain, + native_decimals, + symbol + }; + + WrappedAsset { + info, + treasury_cap, + decimals, + upgrade_cap + } + } + + #[test_only] + public fun new_test_only( + token_meta: AssetMeta, + coin_meta: &mut CoinMetadata, + treasury_cap: TreasuryCap, + upgrade_cap: UpgradeCap + ): WrappedAsset { + new(token_meta, coin_meta, treasury_cap, upgrade_cap) + } + + /// Update existing `ForeignInfo` using new `AssetMeta`. + /// + /// See `token_registry` module for more info. + public(friend) fun update_metadata( + self: &mut WrappedAsset, + coin_meta: &mut CoinMetadata, + token_meta: AssetMeta + ) { + // NOTE: We ignore `native_decimals` because we do not enforce that + // an asset's decimals on a foreign network needs to stay the same. + let ( + token_address, + token_chain, + _native_decimals, + symbol, + name + ) = asset_meta::unpack(token_meta); + + // Verify canonical token info. Also check that the native decimals + // have not changed (because changing this info is not desirable, as + // this change means the supply changed on its native network). + // + // NOTE: This implicitly verifies that `token_chain` is not Iota's + // because this was checked already when the asset was first added. + let (expected_chain, expected_address) = canonical_info(self); + assert!( + ( + token_chain == expected_chain && + token_address == expected_address + ), + E_ASSET_META_MISMATCH + ); + + // Finally only update the name and symbol. + self.info.symbol = symbol; + coin::update_name(&self.treasury_cap, coin_meta, name); + coin::update_symbol(&self.treasury_cap, coin_meta, string_utils::to_ascii(&symbol)); + } + + #[test_only] + public fun update_metadata_test_only( + self: &mut WrappedAsset, + coin_meta: &mut CoinMetadata, + token_meta: AssetMeta + ) { + update_metadata(self, coin_meta, token_meta) + } + + /// Retrieve immutable reference to `ForeignInfo`. + public fun info(self: &WrappedAsset): &ForeignInfo { + &self.info + } + + /// Retrieve canonical token chain ID from `ForeignInfo`. + public fun token_chain(info: &ForeignInfo): u16 { + info.token_chain + } + + /// Retrieve canonical token address from `ForeignInfo`. + public fun token_address(info: &ForeignInfo): ExternalAddress { + info.token_address + } + + /// Retrieve decimal amount from `ForeignInfo`. + /// + /// NOTE: This is for informational purposes. This decimal amount is not + /// used for any calculations. + public fun native_decimals(info: &ForeignInfo): u8 { + info.native_decimals + } + + /// Retrieve asset's symbol (UTF-8) from `ForeignMetadata`. + /// + /// NOTE: This value can be updated. + public fun symbol(info: &ForeignInfo): String { + info.symbol + } + + /// Retrieve total minted supply. + public fun total_supply(self: &WrappedAsset): u64 { + coin::total_supply(&self.treasury_cap) + } + + /// Retrieve decimals for this wrapped asset. For any asset whose native + /// decimals is greater than the cap (8), this will be 8. + /// + /// See `normalized_amount` module for more info. + public fun decimals(self: &WrappedAsset): u8 { + self.decimals + } + + /// Retrieve canonical token chain ID and token address. + public fun canonical_info( + self: &WrappedAsset + ): (u16, ExternalAddress) { + (self.info.token_chain, self.info.token_address) + } + + /// Burn a given `Balance`. `Balance` originates from an outbound token + /// transfer for a wrapped asset. + /// + /// See `transfer_tokens` module for more info. + public(friend) fun burn( + self: &mut WrappedAsset, + burned: Balance + ): u64 { + balance::decrease_supply(coin::supply_mut(&mut self.treasury_cap), burned) + } + + #[test_only] + public fun burn_test_only( + self: &mut WrappedAsset, + burned: Balance + ): u64 { + burn(self, burned) + } + + /// Mint a given amount. This amount is determined by an inbound token + /// transfer payload for a wrapped asset. + /// + /// See `complete_transfer` module for more info. + public(friend) fun mint( + self: &mut WrappedAsset, + amount: u64 + ): Balance { + coin::mint_balance(&mut self.treasury_cap, amount) + } + + #[test_only] + public fun mint_test_only( + self: &mut WrappedAsset, + amount: u64 + ): Balance { + mint(self, amount) + } + + #[test_only] + public fun destroy(asset: WrappedAsset) { + let WrappedAsset { + info, + treasury_cap, + decimals: _, + upgrade_cap + } = asset; + iota::test_utils::destroy(treasury_cap); + + let ForeignInfo { + token_chain: _, + token_address: _, + native_decimals: _, + symbol: _ + } = info; + + iota::package::make_immutable(upgrade_cap); + } +} + +#[test_only] +module token_bridge::wrapped_asset_tests { + use std::string::{Self}; + use iota::balance::{Self}; + use iota::coin::{Self, CoinMetadata}; + use iota::object::{Self}; + use iota::package::{Self}; + use iota::test_scenario::{Self}; + use wormhole::external_address::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::asset_meta::{Self}; + use token_bridge::string_utils; + use token_bridge::coin_native_10::{COIN_NATIVE_10, Self}; + use token_bridge::coin_wrapped_12::{COIN_WRAPPED_12, Self}; + use token_bridge::coin_wrapped_7::{COIN_WRAPPED_7, Self}; + use token_bridge::token_bridge_scenario::{person}; + use token_bridge::wrapped_asset::{Self}; + + #[test] + fun test_wrapped_asset_7() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let parsed_meta = coin_wrapped_7::token_meta(); + let expected_token_chain = asset_meta::token_chain(&parsed_meta); + let expected_token_address = asset_meta::token_address(&parsed_meta); + let expected_native_decimals = + asset_meta::native_decimals(&parsed_meta); + let expected_symbol = asset_meta::symbol(&parsed_meta); + let expected_name = asset_meta::name(&parsed_meta); + + // Publish coin. + let treasury_cap = + coin_wrapped_7::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Upgrade cap belonging to coin type. + let upgrade_cap = + package::test_publish( + object::id_from_address(@token_bridge), + test_scenario::ctx(scenario) + ); + + let coin_meta: CoinMetadata = test_scenario::take_shared(scenario); + + // Make new. + let asset = + wrapped_asset::new_test_only( + parsed_meta, + &mut coin_meta, + treasury_cap, + upgrade_cap + ); + + // Verify members. + let info = wrapped_asset::info(&asset); + assert!( + wrapped_asset::token_chain(info) == expected_token_chain, + 0 + ); + assert!( + wrapped_asset::token_address(info) == expected_token_address, + 0 + ); + assert!( + wrapped_asset::native_decimals(info) == expected_native_decimals, + 0 + ); + assert!(coin::get_symbol(&coin_meta) == string_utils::to_ascii(&expected_symbol), 0); + assert!(coin::get_name(&coin_meta) == expected_name, 0); + assert!(wrapped_asset::total_supply(&asset) == 0, 0); + + let (token_chain, token_address) = + wrapped_asset::canonical_info(&asset); + assert!(token_chain == expected_token_chain, 0); + assert!(token_address == expected_token_address, 0); + + // Decimals are read from `CoinMetadata`, but in this case will agree + // with the value encoded in the VAA. + assert!(wrapped_asset::decimals(&asset) == expected_native_decimals, 0); + assert!(coin::get_decimals(&coin_meta) == expected_native_decimals, 0); + + // Change name and symbol for update. + let new_symbol = std::ascii::into_bytes(coin::get_symbol(&coin_meta)); + + std::vector::append(&mut new_symbol, b"??? and profit"); + assert!(new_symbol != *string::bytes(&expected_symbol), 0); + + let new_name = coin::get_name(&coin_meta); + string::append(&mut new_name, string::utf8(b"??? and profit")); + assert!(new_name != expected_name, 0); + + let updated_meta = + asset_meta::new( + expected_token_address, + expected_token_chain, + expected_native_decimals, + string::utf8(new_symbol), + new_name + ); + + // Update metadata now. + wrapped_asset::update_metadata_test_only(&mut asset, &mut coin_meta, updated_meta); + + assert!(coin::get_symbol(&coin_meta) == std::ascii::string(new_symbol), 0); + assert!(coin::get_name(&coin_meta) == new_name, 0); + + // Try to mint. + let mint_amount = 420; + let collected = balance::zero(); + let (i, n) = (0, 8); + while (i < n) { + let minted = + wrapped_asset::mint_test_only(&mut asset, mint_amount); + assert!(balance::value(&minted) == mint_amount, 0); + balance::join(&mut collected, minted); + i = i + 1; + }; + assert!(balance::value(&collected) == n * mint_amount, 0); + assert!( + wrapped_asset::total_supply(&asset) == balance::value(&collected), + 0 + ); + + // Now try to burn. + let burn_amount = 69; + let i = 0; + while (i < n) { + let burned = balance::split(&mut collected, burn_amount); + let check_amount = + wrapped_asset::burn_test_only(&mut asset, burned); + assert!(check_amount == burn_amount, 0); + i = i + 1; + }; + let remaining = n * mint_amount - n * burn_amount; + assert!(wrapped_asset::total_supply(&asset) == remaining, 0); + assert!(balance::value(&collected) == remaining, 0); + + test_scenario::return_shared(coin_meta); + + // Clean up. + balance::destroy_for_testing(collected); + wrapped_asset::destroy(asset); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_wrapped_asset_12() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let parsed_meta = coin_wrapped_12::token_meta(); + let expected_token_chain = asset_meta::token_chain(&parsed_meta); + let expected_token_address = asset_meta::token_address(&parsed_meta); + let expected_native_decimals = + asset_meta::native_decimals(&parsed_meta); + let expected_symbol = asset_meta::symbol(&parsed_meta); + let expected_name = asset_meta::name(&parsed_meta); + + // Publish coin. + let treasury_cap = + coin_wrapped_12::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Upgrade cap belonging to coin type. + let upgrade_cap = + package::test_publish( + object::id_from_address(@token_bridge), + test_scenario::ctx(scenario) + ); + + let coin_meta: CoinMetadata = test_scenario::take_shared(scenario); + + // Make new. + let asset = + wrapped_asset::new_test_only( + parsed_meta, + &mut coin_meta, + treasury_cap, + upgrade_cap + ); + + // Verify members. + let info = wrapped_asset::info(&asset); + assert!( + wrapped_asset::token_chain(info) == expected_token_chain, + 0 + ); + assert!( + wrapped_asset::token_address(info) == expected_token_address, + 0 + ); + assert!( + wrapped_asset::native_decimals(info) == expected_native_decimals, + 0 + ); + assert!(coin::get_symbol(&coin_meta) == string_utils::to_ascii(&expected_symbol), 0); + assert!(coin::get_name(&coin_meta) == expected_name, 0); + assert!(wrapped_asset::total_supply(&asset) == 0, 0); + + let (token_chain, token_address) = + wrapped_asset::canonical_info(&asset); + assert!(token_chain == expected_token_chain, 0); + assert!(token_address == expected_token_address, 0); + + // Decimals are read from `CoinMetadata`, but in this case will not + // agree with the value encoded in the VAA. + assert!(wrapped_asset::decimals(&asset) == 8, 0); + assert!( + coin::get_decimals(&coin_meta) == wrapped_asset::decimals(&asset), + 0 + ); + assert!(wrapped_asset::decimals(&asset) != expected_native_decimals, 0); + + // Change name and symbol for update. + let new_symbol = std::ascii::into_bytes(coin::get_symbol(&coin_meta)); + + std::vector::append(&mut new_symbol, b"??? and profit"); + assert!(new_symbol != *string::bytes(&expected_symbol), 0); + + let new_name = coin::get_name(&coin_meta); + string::append(&mut new_name, string::utf8(b"??? and profit")); + assert!(new_name != expected_name, 0); + + let updated_meta = + asset_meta::new( + expected_token_address, + expected_token_chain, + expected_native_decimals, + string::utf8(new_symbol), + new_name + ); + + // Update metadata now. + wrapped_asset::update_metadata_test_only(&mut asset, &mut coin_meta, updated_meta); + + assert!(coin::get_symbol(&coin_meta) == std::ascii::string(new_symbol), 0); + assert!(coin::get_name(&coin_meta) == new_name, 0); + + // Try to mint. + let mint_amount = 420; + let collected = balance::zero(); + let (i, n) = (0, 8); + while (i < n) { + let minted = + wrapped_asset::mint_test_only(&mut asset, mint_amount); + assert!(balance::value(&minted) == mint_amount, 0); + balance::join(&mut collected, minted); + i = i + 1; + }; + assert!(balance::value(&collected) == n * mint_amount, 0); + assert!( + wrapped_asset::total_supply(&asset) == balance::value(&collected), + 0 + ); + + // Now try to burn. + let burn_amount = 69; + let i = 0; + while (i < n) { + let burned = balance::split(&mut collected, burn_amount); + let check_amount = + wrapped_asset::burn_test_only(&mut asset, burned); + assert!(check_amount == burn_amount, 0); + i = i + 1; + }; + let remaining = n * mint_amount - n * burn_amount; + assert!(wrapped_asset::total_supply(&asset) == remaining, 0); + assert!(balance::value(&collected) == remaining, 0); + + // Clean up. + balance::destroy_for_testing(collected); + wrapped_asset::destroy(asset); + test_scenario::return_shared(coin_meta); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wrapped_asset::E_SUI_CHAIN)] + // In this negative test case, we attempt to register a native coin as a + // wrapped coin. + fun test_cannot_new_sui_chain() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize new coin type. + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Iota's chain ID is not allowed. + let invalid_meta = + asset_meta::new( + external_address::default(), + chain_id(), + 10, + string::utf8(b""), + string::utf8(b"") + ); + + // Upgrade cap belonging to coin type. + let upgrade_cap = + package::test_publish( + object::id_from_address(@token_bridge), + test_scenario::ctx(scenario) + ); + + let treasury_cap = test_scenario::take_shared>(scenario); + let coin_meta = test_scenario::take_shared>(scenario); + + // You shall not pass! + let asset = + wrapped_asset::new_test_only( + invalid_meta, + &mut coin_meta, + treasury_cap, + upgrade_cap + ); + + // Clean up. + wrapped_asset::destroy(asset); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wrapped_asset::E_ASSET_META_MISMATCH)] + /// In this negative test case, we attempt to update with a mismatching + /// chain. + fun test_cannot_update_metadata_asset_meta_mismatch_token_address() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let parsed_meta = coin_wrapped_12::token_meta(); + let expected_token_chain = asset_meta::token_chain(&parsed_meta); + let expected_token_address = asset_meta::token_address(&parsed_meta); + let expected_native_decimals = + asset_meta::native_decimals(&parsed_meta); + + // Publish coin. + let treasury_cap = + coin_wrapped_12::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Upgrade cap belonging to coin type. + let upgrade_cap = + package::test_publish( + object::id_from_address(@token_bridge), + test_scenario::ctx(scenario) + ); + + let coin_meta = test_scenario::take_shared(scenario); + + // Make new. + let asset = + wrapped_asset::new_test_only( + parsed_meta, + &mut coin_meta, + treasury_cap, + upgrade_cap + ); + + let invalid_meta = + asset_meta::new( + external_address::default(), + expected_token_chain, + expected_native_decimals, + string::utf8(b""), + string::utf8(b""), + ); + assert!( + asset_meta::token_address(&invalid_meta) != expected_token_address, + 0 + ); + assert!( + asset_meta::token_chain(&invalid_meta) == expected_token_chain, + 0 + ); + assert!( + asset_meta::native_decimals(&invalid_meta) == expected_native_decimals, + 0 + ); + + // You shall not pass! + wrapped_asset::update_metadata_test_only(&mut asset, &mut coin_meta, invalid_meta); + + // Clean up. + wrapped_asset::destroy(asset); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wrapped_asset::E_ASSET_META_MISMATCH)] + /// In this negative test case, we attempt to update with a mismatching + /// chain. + fun test_cannot_update_metadata_asset_meta_mismatch_token_chain() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let parsed_meta = coin_wrapped_12::token_meta(); + let expected_token_chain = asset_meta::token_chain(&parsed_meta); + let expected_token_address = asset_meta::token_address(&parsed_meta); + let expected_native_decimals = + asset_meta::native_decimals(&parsed_meta); + + // Publish coin. + let treasury_cap = + coin_wrapped_12::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Upgrade cap belonging to coin type. + let upgrade_cap = + package::test_publish( + object::id_from_address(@token_bridge), + test_scenario::ctx(scenario) + ); + + let coin_meta = test_scenario::take_shared(scenario); + + // Make new. + let asset = + wrapped_asset::new_test_only( + parsed_meta, + &mut coin_meta, + treasury_cap, + upgrade_cap + ); + + let invalid_meta = + asset_meta::new( + expected_token_address, + chain_id(), + expected_native_decimals, + string::utf8(b""), + string::utf8(b""), + ); + assert!( + asset_meta::token_address(&invalid_meta) == expected_token_address, + 0 + ); + assert!( + asset_meta::token_chain(&invalid_meta) != expected_token_chain, + 0 + ); + assert!( + asset_meta::native_decimals(&invalid_meta) == expected_native_decimals, + 0 + ); + + // You shall not pass! + wrapped_asset::update_metadata_test_only(&mut asset, &mut coin_meta, invalid_meta); + + // Clean up. + wrapped_asset::destroy(asset); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = wormhole::package_utils::E_INVALID_UPGRADE_CAP + )] + fun test_cannot_new_upgrade_cap_mismatch() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Publish coin. + let treasury_cap = + coin_wrapped_12::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Upgrade cap belonging to coin type. + let upgrade_cap = + package::test_publish( + object::id_from_address(@0xbadc0de), + test_scenario::ctx(scenario) + ); + + let coin_meta = test_scenario::take_shared(scenario); + + // You shall not pass! + let asset = + wrapped_asset::new_test_only( + coin_wrapped_12::token_meta(), + &mut coin_meta, + treasury_cap, + upgrade_cap + ); + + // Clean up. + wrapped_asset::destroy(asset); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/setup.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/setup.move new file mode 100644 index 0000000000..246dae0100 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/setup.move @@ -0,0 +1,78 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements the mechanism to publish the Token Bridge contract +/// and initialize `State` as a shared object. +module token_bridge::setup { + use iota::object::{Self, UID}; + use iota::package::{Self, UpgradeCap}; + use iota::transfer::{Self}; + use iota::tx_context::{Self, TxContext}; + use wormhole::emitter::{EmitterCap}; + + use token_bridge::state::{Self}; + + /// Capability created at `init`, which will be destroyed once + /// `init_and_share_state` is called. This ensures only the deployer can + /// create the shared `State`. + struct DeployerCap has key, store { + id: UID + } + + /// Called automatically when module is first published. Transfers + /// `DeployerCap` to sender. + /// + /// Only `setup::init_and_share_state` requires `DeployerCap`. + fun init(ctx: &mut TxContext) { + let deployer = DeployerCap { id: object::new(ctx) }; + transfer::transfer(deployer, tx_context::sender(ctx)); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + // NOTE: This exists to mock up iota::package for proposed upgrades. + use iota::package::{Self}; + + init(ctx); + + // This will be created and sent to the transaction sender + // automatically when the contract is published. + transfer::public_transfer( + package::test_publish(object::id_from_address(@token_bridge), ctx), + tx_context::sender(ctx) + ); + } + + #[allow(lint(share_owned))] + /// Only the owner of the `DeployerCap` can call this method. This + /// method destroys the capability and shares the `State` object. + public fun complete( + deployer: DeployerCap, + upgrade_cap: UpgradeCap, + emitter_cap: EmitterCap, + governance_chain: u16, + governance_contract: vector, + ctx: &mut TxContext + ) { + wormhole::package_utils::assert_package_upgrade_cap( + &upgrade_cap, + package::compatible_policy(), + 1 + ); + + // Destroy deployer cap. + let DeployerCap { id } = deployer; + object::delete(id); + + // Share new state. + transfer::public_share_object( + state::new( + emitter_cap, + upgrade_cap, + governance_chain, + wormhole::external_address::new_nonzero( + wormhole::bytes32::from_bytes(governance_contract) + ), + ctx + )); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/state.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/state.move new file mode 100644 index 0000000000..f16ad7ffab --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/state.move @@ -0,0 +1,396 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements the global state variables for Token Bridge as a +/// shared object. The `State` object is used to perform anything that requires +/// access to data that defines the Token Bridge contract. Examples of which are +/// accessing registered assets and verifying `VAA` intended for Token Bridge by +/// checking the emitter against its own registered emitters. +module token_bridge::state { + use iota::object::{Self, ID, UID}; + use iota::package::{UpgradeCap, UpgradeReceipt, UpgradeTicket}; + use iota::table::{Self, Table}; + use iota::tx_context::{TxContext}; + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::consumed_vaas::{Self, ConsumedVAAs}; + use wormhole::emitter::{EmitterCap}; + use wormhole::external_address::{ExternalAddress}; + use wormhole::package_utils::{Self}; + use wormhole::publish_message::{MessageTicket}; + + use token_bridge::token_registry::{Self, TokenRegistry, VerifiedAsset}; + use token_bridge::version_control::{Self}; + + /// Build digest does not agree with current implementation. + const E_INVALID_BUILD_DIGEST: u64 = 0; + /// Specified version does not match this build's version. + const E_VERSION_MISMATCH: u64 = 1; + /// Emitter has already been used to emit Wormhole messages. + const E_USED_EMITTER: u64 = 2; + + friend token_bridge::attest_token; + friend token_bridge::complete_transfer; + friend token_bridge::complete_transfer_with_payload; + friend token_bridge::create_wrapped; + friend token_bridge::migrate; + friend token_bridge::register_chain; + friend token_bridge::setup; + friend token_bridge::transfer_tokens; + friend token_bridge::transfer_tokens_with_payload; + friend token_bridge::upgrade_contract; + friend token_bridge::vaa; + + /// Capability reflecting that the current build version is used to invoke + /// state methods. + struct LatestOnly has drop {} + + /// Container for all state variables for Token Bridge. + struct State has key, store { + id: UID, + + /// Governance chain ID. + governance_chain: u16, + + /// Governance contract address. + governance_contract: ExternalAddress, + + /// Set of consumed VAA hashes. + consumed_vaas: ConsumedVAAs, + + /// Emitter capability required to publish Wormhole messages. + emitter_cap: EmitterCap, + + /// Registry for foreign Token Bridge contracts. + emitter_registry: Table, + + /// Registry for native and wrapped assets. + token_registry: TokenRegistry, + + /// Upgrade capability. + upgrade_cap: UpgradeCap + } + + /// Create new `State`. This is only executed using the `setup` module. + public(friend) fun new( + emitter_cap: EmitterCap, + upgrade_cap: UpgradeCap, + governance_chain: u16, + governance_contract: ExternalAddress, + ctx: &mut TxContext + ): State { + assert!(wormhole::emitter::sequence(&emitter_cap) == 0, E_USED_EMITTER); + + let state = State { + id: object::new(ctx), + governance_chain, + governance_contract, + consumed_vaas: consumed_vaas::new(ctx), + emitter_cap, + emitter_registry: table::new(ctx), + token_registry: token_registry::new(ctx), + upgrade_cap + }; + + // Set first version and initialize package info. This will be used for + // emitting information of successful migrations. + let upgrade_cap = &state.upgrade_cap; + package_utils::init_package_info( + &mut state.id, + version_control::current_version(), + upgrade_cap + ); + + state + } + + //////////////////////////////////////////////////////////////////////////// + // + // Simple Getters + // + // These methods do not require `LatestOnly` for access. Anyone is free to + // access these values. + // + //////////////////////////////////////////////////////////////////////////// + + /// Retrieve governance module name. + public fun governance_module(): Bytes32 { + // A.K.A. "TokenBridge". + bytes32::new( + x"000000000000000000000000000000000000000000546f6b656e427269646765" + ) + } + + /// Retrieve governance chain ID, which is governance's emitter chain ID. + public fun governance_chain(self: &State): u16 { + self.governance_chain + } + + /// Retrieve governance emitter address. + public fun governance_contract(self: &State): ExternalAddress { + self.governance_contract + } + + /// Retrieve immutable reference to `TokenRegistry`. + public fun borrow_token_registry( + self: &State + ): &TokenRegistry { + &self.token_registry + } + + public fun borrow_emitter_registry( + self: &State + ): &Table { + &self.emitter_registry + } + + public fun verified_asset( + self: &State + ): VerifiedAsset { + token_registry::assert_has(&self.token_registry); + token_registry::verified_asset(&self.token_registry) + } + + #[test_only] + public fun borrow_mut_token_registry_test_only( + self: &mut State + ): &mut TokenRegistry { + borrow_mut_token_registry(&assert_latest_only(self), self) + } + + #[test_only] + public fun migrate_version_test_only( + self: &mut State, + old_version: Old, + new_version: New + ) { + wormhole::package_utils::update_version_type_test_only( + &mut self.id, + old_version, + new_version + ); + } + + #[test_only] + public fun test_upgrade(self: &mut State) { + let test_digest = bytes32::from_bytes(b"new build"); + let ticket = authorize_upgrade(self, test_digest); + let receipt = iota::package::test_upgrade(ticket); + commit_upgrade(self, receipt); + } + + #[test_only] + public fun reverse_migrate_version(self: &mut State) { + package_utils::update_version_type_test_only( + &mut self.id, + version_control::current_version(), + version_control::previous_version() + ); + } + + //////////////////////////////////////////////////////////////////////////// + // + // Privileged `State` Access + // + // This section of methods require a `LatestOnly`, which can only be + // created within the Token Bridge package. This capability allows special + // access to the `State` object where we require that the latest build is + // used for these interactions. + // + // NOTE: A lot of these methods are still marked as `(friend)` as a safety + // precaution. When a package is upgraded, friend modifiers can be + // removed. + // + //////////////////////////////////////////////////////////////////////////// + + /// Obtain a capability to interact with `State` methods. This method checks + /// that we are running the current build. + /// + /// NOTE: This method allows caching the current version check so we avoid + /// multiple checks to dynamic fields. + public(friend) fun assert_latest_only(self: &State): LatestOnly { + package_utils::assert_version( + &self.id, + version_control::current_version() + ); + + LatestOnly {} + } + + /// Obtain a capability to interact with `State` methods. This method checks + /// that we are running the current build and that the specified `Version` + /// equals the current version. This method is useful when external modules + /// invoke Token Bridge and we need to check that the external module's + /// version is up-to-date (e.g. `create_wrapped::prepare_registration`). + /// + /// NOTE: This method allows caching the current version check so we avoid + /// multiple checks to dynamic fields. + public(friend) fun assert_latest_only_specified( + self: &State + ): LatestOnly { + use std::type_name::{get}; + + // Explicitly check the type names. + let current_type = + package_utils::type_of_version(version_control::current_version()); + assert!(current_type == get(), E_VERSION_MISMATCH); + + assert_latest_only(self) + } + + /// Store `VAA` hash as a way to claim a VAA. This method prevents a VAA + /// from being replayed. + public(friend) fun borrow_mut_consumed_vaas( + _: &LatestOnly, + self: &mut State + ): &mut ConsumedVAAs { + borrow_mut_consumed_vaas_unchecked(self) + } + + /// Store `VAA` hash as a way to claim a VAA. This method prevents a VAA + /// from being replayed. + /// + /// NOTE: This method does not require `LatestOnly`. Only methods in the + /// `upgrade_contract` module requires this to be unprotected to prevent + /// a corrupted upgraded contract from bricking upgradability. + public(friend) fun borrow_mut_consumed_vaas_unchecked( + self: &mut State + ): &mut ConsumedVAAs { + &mut self.consumed_vaas + } + + /// Publish Wormhole message using Token Bridge's `EmitterCap`. + public(friend) fun prepare_wormhole_message( + _: &LatestOnly, + self: &mut State, + nonce: u32, + payload: vector + ): MessageTicket { + wormhole::publish_message::prepare_message( + &mut self.emitter_cap, + nonce, + payload, + ) + } + + /// Retrieve mutable reference to `TokenRegistry`. + public(friend) fun borrow_mut_token_registry( + _: &LatestOnly, + self: &mut State + ): &mut TokenRegistry { + &mut self.token_registry + } + + public(friend) fun borrow_mut_emitter_registry( + _: &LatestOnly, + self: &mut State + ): &mut Table { + &mut self.emitter_registry + } + + public(friend) fun current_package(_: &LatestOnly, self: &State): ID { + package_utils::current_package(&self.id) + } + + //////////////////////////////////////////////////////////////////////////// + // + // Upgradability + // + // A special space that controls upgrade logic. These methods are invoked + // via the `upgrade_contract` module. + // + // Also in this section is managing contract migrations, which uses the + // `migrate` module to officially roll state access to the latest build. + // Only those methods that require `LatestOnly` will be affected by an + // upgrade. + // + //////////////////////////////////////////////////////////////////////////// + + /// Issue an `UpgradeTicket` for the upgrade. + /// + /// NOTE: The Iota VM performs a check that this method is executed from the + /// latest published package. If someone were to try to execute this using + /// a stale build, the transaction will revert with `PackageUpgradeError`, + /// specifically `PackageIDDoesNotMatch`. + public(friend) fun authorize_upgrade( + self: &mut State, + package_digest: Bytes32 + ): UpgradeTicket { + let cap = &mut self.upgrade_cap; + package_utils::authorize_upgrade(&mut self.id, cap, package_digest) + } + + /// Finalize the upgrade that ran to produce the given `receipt`. + /// + /// NOTE: The Iota VM performs a check that this method is executed from the + /// latest published package. If someone were to try to execute this using + /// a stale build, the transaction will revert with `PackageUpgradeError`, + /// specifically `PackageIDDoesNotMatch`. + public(friend) fun commit_upgrade( + self: &mut State, + receipt: UpgradeReceipt + ): (ID, ID) { + let cap = &mut self.upgrade_cap; + package_utils::commit_upgrade(&mut self.id, cap, receipt) + } + + /// Method executed by the `migrate` module to roll access from one package + /// to another. This method will be called from the upgraded package. + public(friend) fun migrate_version(self: &mut State) { + package_utils::migrate_version( + &mut self.id, + version_control::previous_version(), + version_control::current_version() + ); + } + + /// As a part of the migration, we verify that the upgrade contract VAA's + /// encoded package digest used in `migrate` equals the one used to conduct + /// the upgrade. + public(friend) fun assert_authorized_digest( + _: &LatestOnly, + self: &State, + digest: Bytes32 + ) { + let authorized = package_utils::authorized_digest(&self.id); + assert!(digest == authorized, E_INVALID_BUILD_DIGEST); + } + + //////////////////////////////////////////////////////////////////////////// + // + // Special State Interaction via Migrate + // + // A VERY special space that manipulates `State` via calling `migrate`. + // + // PLEASE KEEP ANY METHODS HERE AS FRIENDS. We want the ability to remove + // these for future builds. + // + //////////////////////////////////////////////////////////////////////////// + + /// This method is used to make modifications to `State` when `migrate` is + /// called. This method name should change reflecting which version this + /// contract is migrating to. + /// + /// NOTE: Please keep this method as public(friend) because we never want + /// to expose this method as a public method. + public(friend) fun migrate__v__0_2_0(_self: &mut State) { + // Intentionally do nothing. + } + + #[test_only] + /// Bloody hack. + /// + /// This method is used to set up tests where we migrate to a new version, + /// which is meant to test that modules protected by version control will + /// break. + public fun reverse_migrate__v__dummy(_self: &mut State) { + // Intentionally do nothing. + } + + //////////////////////////////////////////////////////////////////////////// + // + // Deprecated + // + // Dumping grounds for old structs and methods. These things should not + // be used in future builds. + // + //////////////////////////////////////////////////////////////////////////// +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/coin_native_10.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/coin_native_10.move new file mode 100644 index 0000000000..f58a56d727 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/coin_native_10.move @@ -0,0 +1,165 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +module token_bridge::coin_native_10 { + use std::option::{Self}; + use iota::balance::{Self, Balance}; + use iota::coin::{Self, CoinMetadata, TreasuryCap}; + use iota::test_scenario::{Self, Scenario}; + use iota::transfer::{Self}; + use iota::tx_context::{TxContext}; + + use token_bridge::native_asset::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_registry::{Self}; + + struct COIN_NATIVE_10 has drop {} + + // This module creates a Iota-native token for testing purposes, + // for example in complete_transfer, where we create a native coin, + // mint some and deposit in the token bridge, then complete transfer + // and ultimately transfer a portion of those native coins to a recipient. + fun init(coin_witness: COIN_NATIVE_10, ctx: &mut TxContext) { + let ( + treasury_cap, + coin_metadata + ) = + coin::create_currency( + coin_witness, + 10, + b"DEC10", + b"Decimals 10", + b"Coin with 10 decimals for testing purposes.", + option::none(), + ctx + ); + + // Allow us to mutate metadata if we need. + transfer::public_share_object(coin_metadata); + + // Give everyone access to `TrasuryCap`. + transfer::public_share_object(treasury_cap); + } + + #[test_only] + /// For a test scenario, register this native asset. + /// + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_and_register(scenario: &mut Scenario, caller: address) { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Publish coin. + init(COIN_NATIVE_10 {}, test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + let coin_meta = take_metadata(scenario); + + // Register asset. + let registry = + state::borrow_mut_token_registry_test_only(&mut token_bridge_state); + token_registry::add_new_native_test_only(registry, &coin_meta); + + // Clean up. + return_state(token_bridge_state); + return_metadata(coin_meta); + } + + #[test_only] + public fun init_register_and_mint( + scenario: &mut Scenario, + caller: address, + amount: u64 + ): Balance { + // First publish and register. + init_and_register(scenario, caller); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Mint. + balance::create_for_testing(amount) + } + + #[test_only] + public fun init_register_and_deposit( + scenario: &mut Scenario, + caller: address, + amount: u64 + ) { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + + let minted = init_register_and_mint(scenario, caller, amount); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + native_asset::deposit_test_only( + token_registry::borrow_mut_native_test_only( + state::borrow_mut_token_registry_test_only( + &mut token_bridge_state + ) + ), + minted + ); + + return_state(token_bridge_state); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_NATIVE_10 {}, ctx); + } + + public fun take_metadata( + scenario: &Scenario + ): CoinMetadata { + test_scenario::take_shared(scenario) + } + + public fun return_metadata( + metadata: CoinMetadata + ) { + test_scenario::return_shared(metadata); + } + + public fun take_treasury_cap( + scenario: &Scenario + ): TreasuryCap { + test_scenario::take_shared(scenario) + } + + public fun return_treasury_cap( + treasury_cap: TreasuryCap + ) { + test_scenario::return_shared(treasury_cap); + } + + public fun take_globals( + scenario: &Scenario + ): ( + TreasuryCap, + CoinMetadata + ) { + ( + take_treasury_cap(scenario), + take_metadata(scenario) + ) + } + + public fun return_globals( + treasury_cap: TreasuryCap, + metadata: CoinMetadata + ) { + return_treasury_cap(treasury_cap); + return_metadata(metadata); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/coin_native_4.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/coin_native_4.move new file mode 100644 index 0000000000..b9c2621005 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/coin_native_4.move @@ -0,0 +1,165 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +module token_bridge::coin_native_4 { + use std::option::{Self}; + use iota::balance::{Self, Balance}; + use iota::coin::{Self, CoinMetadata, TreasuryCap}; + use iota::test_scenario::{Self, Scenario}; + use iota::transfer::{Self}; + use iota::tx_context::{TxContext}; + + use token_bridge::native_asset::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_registry::{Self}; + + struct COIN_NATIVE_4 has drop {} + + // This module creates a Iota-native token for testing purposes, + // for example in complete_transfer, where we create a native coin, + // mint some and deposit in the token bridge, then complete transfer + // and ultimately transfer a portion of those native coins to a recipient. + fun init(coin_witness: COIN_NATIVE_4, ctx: &mut TxContext) { + let ( + treasury_cap, + coin_metadata + ) = + coin::create_currency( + coin_witness, + 4, + b"DEC4", + b"Decimals 4", + b"Coin with 4 decimals for testing purposes.", + option::none(), + ctx + ); + + // Let's make the metadata shared. + transfer::public_share_object(coin_metadata); + + // Give everyone access to `TrasuryCap`. + transfer::public_share_object(treasury_cap); + } + + #[test_only] + /// For a test scenario, register this native asset. + /// + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_and_register(scenario: &mut Scenario, caller: address) { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Publish coin. + init(COIN_NATIVE_4 {}, test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + let coin_meta = take_metadata(scenario); + + // Register asset. + let registry = + state::borrow_mut_token_registry_test_only(&mut token_bridge_state); + token_registry::add_new_native_test_only(registry, &coin_meta); + + // Clean up. + return_state(token_bridge_state); + return_metadata(coin_meta); + } + + #[test_only] + public fun init_register_and_mint( + scenario: &mut Scenario, + caller: address, + amount: u64 + ): Balance { + // First publish and register. + init_and_register(scenario, caller); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Mint. + balance::create_for_testing(amount) + } + + #[test_only] + public fun init_register_and_deposit( + scenario: &mut Scenario, + caller: address, + amount: u64 + ) { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + + let minted = init_register_and_mint(scenario, caller, amount); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + native_asset::deposit_test_only( + token_registry::borrow_mut_native_test_only( + state::borrow_mut_token_registry_test_only( + &mut token_bridge_state + ) + ), + minted + ); + + return_state(token_bridge_state); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_NATIVE_4 {}, ctx); + } + + public fun take_metadata( + scenario: &Scenario + ): CoinMetadata { + test_scenario::take_shared(scenario) + } + + public fun return_metadata( + metadata: CoinMetadata + ) { + test_scenario::return_shared(metadata); + } + + public fun take_treasury_cap( + scenario: &Scenario + ): TreasuryCap { + test_scenario::take_shared(scenario) + } + + public fun return_treasury_cap( + treasury_cap: TreasuryCap + ) { + test_scenario::return_shared(treasury_cap); + } + + public fun take_globals( + scenario: &Scenario + ): ( + TreasuryCap, + CoinMetadata + ) { + ( + take_treasury_cap(scenario), + take_metadata(scenario) + ) + } + + public fun return_globals( + treasury_cap: TreasuryCap, + metadata: CoinMetadata + ) { + return_treasury_cap(treasury_cap); + return_metadata(metadata); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/coin_wrapped_12.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/coin_wrapped_12.move new file mode 100644 index 0000000000..242b4b0ccf --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/coin_wrapped_12.move @@ -0,0 +1,193 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +module token_bridge::coin_wrapped_12 { + use iota::balance::{Balance}; + use iota::package::{UpgradeCap}; + use iota::coin::{CoinMetadata, TreasuryCap}; + use iota::test_scenario::{Self, Scenario}; + use iota::transfer::{Self}; + use iota::tx_context::{Self, TxContext}; + + use token_bridge::asset_meta::{Self, AssetMeta}; + use token_bridge::create_wrapped::{Self, WrappedAssetSetup}; + use token_bridge::state::{Self}; + use token_bridge::token_registry::{Self}; + use token_bridge::wrapped_asset::{Self}; + + use token_bridge::version_control::{V__0_2_0 as V__CURRENT}; + + struct COIN_WRAPPED_12 has drop {} + + const VAA: vector = + x"0100000000010080366065746148420220f25a6275097370e8db40984529a6676b7a5fc9feb11755ec49ca626b858ddfde88d15601f85ab7683c5f161413b0412143241c700aff010000000100000001000200000000000000000000000000000000000000000000000000000000deadbeef000000000150eb23000200000000000000000000000000000000000000000000000000000000beefface00020c424545460000000000000000000000000000000000000000000000000000000042656566206661636520546f6b656e0000000000000000000000000000000000"; + + const UPDATED_VAA: vector = + x"0100000000010062f4dcd21bbbc4af8b8baaa2da3a0b168efc4c975de5b828c7a3c710b67a0a0d476d10a74aba7a7867866daf97d1372d8e6ee62ccc5ae522e3e603c67fa23787000000000000000045000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f0200000000000000000000000000000000000000000000000000000000beefface00020c424545463f3f3f20616e642070726f666974000000000000000000000000000042656566206661636520546f6b656e3f3f3f20616e642070726f666974000000"; + + fun init(witness: COIN_WRAPPED_12, ctx: &mut TxContext) { + let ( + setup, + upgrade_cap + ) = + create_wrapped::new_setup_current( + witness, + 8, // capped to 8 + ctx + ); + transfer::public_transfer(setup, tx_context::sender(ctx)); + transfer::public_transfer(upgrade_cap, tx_context::sender(ctx)); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_WRAPPED_12 {}, ctx); + } + + + public fun encoded_vaa(): vector { + VAA + } + + public fun encoded_updated_vaa(): vector { + UPDATED_VAA + } + + #[allow(implicit_const_copy)] + public fun token_meta(): AssetMeta { + asset_meta::deserialize_test_only( + wormhole::vaa::peel_payload_from_vaa(&VAA) + ) + } + + #[allow(implicit_const_copy)] + public fun updated_token_meta(): AssetMeta { + asset_meta::deserialize_test_only( + wormhole::vaa::peel_payload_from_vaa(&UPDATED_VAA) + ) + } + + #[test_only] + /// for a test scenario, simply deploy the coin and expose `Supply`. + public fun init_and_take_treasury_cap( + scenario: &mut Scenario, + caller: address + ): TreasuryCap { + use token_bridge::create_wrapped; + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Publish coin. + init(COIN_WRAPPED_12 {}, test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + create_wrapped::take_treasury_cap( + test_scenario::take_from_sender(scenario) + ) + } + + #[test_only] + /// For a test scenario, register this wrapped asset. + /// + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_and_register( + scenario: &mut Scenario, + caller: address + ) { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Publish coin. + init(COIN_WRAPPED_12 {}, test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + let msg = + token_bridge::vaa::verify_only_once( + &mut token_bridge_state, + verified_vaa + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let coin_meta = + test_scenario::take_shared>(scenario); + + // Register the attested asset. + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + test_scenario::take_from_sender< + WrappedAssetSetup + >( + scenario + ), + test_scenario::take_from_sender(scenario), + msg + ); + + test_scenario::return_shared(coin_meta); + + // Clean up. + return_state(token_bridge_state); + } + + #[test_only] + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_register_and_mint( + scenario: &mut Scenario, + caller: address, + amount: u64 + ): Balance { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + + // First publish and register. + init_and_register(scenario, caller); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + let minted = + wrapped_asset::mint_test_only( + token_registry::borrow_mut_wrapped_test_only( + state::borrow_mut_token_registry_test_only( + &mut token_bridge_state + ) + ), + amount + ); + + return_state(token_bridge_state); + + minted + } +} + +#[test_only] +module token_bridge::coin_wrapped_12_tests { + use token_bridge::asset_meta::{Self}; + use token_bridge::coin_wrapped_12::{token_meta}; + + #[test] + fun test_native_decimals() { + let meta = token_meta(); + assert!(asset_meta::native_decimals(&meta) == 12, 0); + asset_meta::destroy(meta); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/coin_wrapped_7.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/coin_wrapped_7.move new file mode 100644 index 0000000000..9ac16322d7 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/coin_wrapped_7.move @@ -0,0 +1,194 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +module token_bridge::coin_wrapped_7 { + use iota::balance::{Balance}; + use iota::coin::{CoinMetadata, TreasuryCap}; + use iota::package::{UpgradeCap}; + use iota::test_scenario::{Self, Scenario}; + use iota::transfer::{Self}; + use iota::tx_context::{Self, TxContext}; + + use token_bridge::asset_meta::{Self, AssetMeta}; + use token_bridge::create_wrapped::{Self, WrappedAssetSetup}; + use token_bridge::state::{Self}; + use token_bridge::token_registry::{Self}; + use token_bridge::wrapped_asset::{Self}; + + use token_bridge::version_control::{V__0_2_0 as V__CURRENT}; + + struct COIN_WRAPPED_7 has drop {} + + // TODO: need to fix the emitter address + // +------------------------------------------------------------------------------+ + // | Wormhole VAA v1 | nonce: 69 | time: 0 | + // | guardian set #0 | #1 | consistency: 15 | + // |------------------------------------------------------------------------------| + // | Signature: | + // | #0: 3d8fd671611d84801dc9d14a07835e8729d217b1aac77b054175d0f91294... | + // |------------------------------------------------------------------------------| + // | Emitter: 0x00000000000000000000000000000000deadbeef (Ethereum) | + // |------------------------------------------------------------------------------| + // | Token attestation | + // | decimals: 7 | + // | Token: 0x00000000000000000000000000000000deafface (Ethereum) | + // | Symbol: DEC7 | + // | Name: DECIMALS 7 | + // +------------------------------------------------------------------------------+ + const VAA: vector = + x"010000000001003d8fd671611d84801dc9d14a07835e8729d217b1aac77b054175d0f91294040742a1ed6f3e732b2fbf208e64422816accf89dd0cd3ead20d2e0fb3d372ce221c010000000000000045000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f0200000000000000000000000000000000000000000000000000000000deafface000207000000000000000000000000000000000000000000000000000000004445433700000000000000000000000000000000000000000000444543494d414c532037"; + + fun init(witness: COIN_WRAPPED_7, ctx: &mut TxContext) { + let ( + setup, + upgrade_cap + ) = + create_wrapped::new_setup_current( + witness, + 7, + ctx + ); + transfer::public_transfer(setup, tx_context::sender(ctx)); + transfer::public_transfer(upgrade_cap, tx_context::sender(ctx)); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_WRAPPED_7 {}, ctx); + } + + public fun encoded_vaa(): vector { + VAA + } + + #[allow(implicit_const_copy)] + public fun token_meta(): AssetMeta { + asset_meta::deserialize_test_only( + wormhole::vaa::peel_payload_from_vaa(&VAA) + ) + } + + #[test_only] + /// for a test scenario, simply deploy the coin and expose `TreasuryCap`. + public fun init_and_take_treasury_cap( + scenario: &mut Scenario, + caller: address + ): TreasuryCap { + use token_bridge::create_wrapped; + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Publish coin. + init(COIN_WRAPPED_7 {}, test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + create_wrapped::take_treasury_cap( + test_scenario::take_from_sender(scenario) + ) + } + + #[test_only] + /// For a test scenario, register this wrapped asset. + /// + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_and_register( + scenario: &mut Scenario, + caller: address + ) { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Publish coin. + init(COIN_WRAPPED_7 {}, test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + let msg = + token_bridge::vaa::verify_only_once( + &mut token_bridge_state, + verified_vaa + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let coin_meta = + test_scenario::take_shared>(scenario); + + // Register the attested asset. + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + test_scenario::take_from_sender< + WrappedAssetSetup + >( + scenario + ), + test_scenario::take_from_sender(scenario), + msg + ); + + test_scenario::return_shared(coin_meta); + + // Clean up. + return_state(token_bridge_state); + } + + #[test_only] + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_register_and_mint( + scenario: &mut Scenario, + caller: address, + amount: u64 + ): Balance { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + + // First publish and register. + init_and_register(scenario, caller); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + let minted = + wrapped_asset::mint_test_only( + token_registry::borrow_mut_wrapped_test_only( + state::borrow_mut_token_registry_test_only( + &mut token_bridge_state + ) + ), + amount + ); + + return_state(token_bridge_state); + + minted + } +} + +#[test_only] +module token_bridge::coin_wrapped_7_tests { + use token_bridge::asset_meta::{Self}; + use token_bridge::coin_wrapped_7::{token_meta}; + + #[test] + fun test_native_decimals() { + let meta = token_meta(); + assert!(asset_meta::native_decimals(&meta) == 7, 0); + asset_meta::destroy(meta); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/dummy_message.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/dummy_message.move new file mode 100644 index 0000000000..d3784e5a97 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/dummy_message.move @@ -0,0 +1,146 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +module token_bridge::dummy_message { + public fun encoded_transfer(): vector { + // let decimals = 8; + // let expected_amount = normalized_amount::from_raw(234567890, decimals); + // let expected_token_address = external_address::from_address(@0xbeef); + // let expected_token_chain = 1; + // let expected_recipient = external_address::from_address(@0xcafe); + // let expected_recipient_chain = 7; + // let expected_relayer_fee = + // normalized_amount::from_raw(123456789, decimals); + x"01000000000000000000000000000000000000000000000000000000000dfb38d2000000000000000000000000000000000000000000000000000000000000beef0001000000000000000000000000000000000000000000000000000000000000cafe000700000000000000000000000000000000000000000000000000000000075bcd15" + } + + public fun encoded_transfer_with_payload(): vector { + // let expected_amount = normalized_amount::from_raw(234567890, 8); + // let expected_token_address = external_address::from_address(@0xbeef); + // let expected_token_chain = 1; + // let expected_recipient = external_address::from_address(@0xcafe); + // let expected_recipient_chain = 7; + // let expected_sender = external_address::from_address(@0xdeadbeef); + // let expected_payload = b"All your base are belong to us."; + x"03000000000000000000000000000000000000000000000000000000000dfb38d2000000000000000000000000000000000000000000000000000000000000beef0001000000000000000000000000000000000000000000000000000000000000cafe0007381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f409416c6c20796f75722062617365206172652062656c6f6e6720746f2075732e" + } + + public fun encoded_transfer_vaa_native_with_fee(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x0000000000000000000000000000000000000000000000000000000000000001', + // tokenChain: 21, + // toAddress: '0x000000000000000000000000000000000000000000000000000000000000b0b1', + // chain: 21, + // fee: 1000n + x"01000000000100bce07d9dce4e16f564788b0885fa31fa6c5c1bb7ee1f7d0948b8f2c2ae9e87ea4eccfc86affb8b7cf8bfcc774effe0fa7a54066d8a4310a4bb0350fd3097ab25000000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f010000000000000000000000000000000000000000000000000000000000000bb80bc9c77af025eb7f73940ad00c9d6f06d45253339a110b0f9ff03b822e5877d30015000000000000000000000000000000000000000000000000000000000000b0b1001500000000000000000000000000000000000000000000000000000000000003e8" + } + + public fun encoded_transfer_with_payload_vaa_native(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x0000000000000000000000000000000000000000000000000000000000000001', + // tokenChain: 21, + // toAddress: '0x381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f409', + // chain: 21, + // fromAddress: '0x000000000000000000000000000000000000000000000000000000000badc0de', + // payload: 'All your base are belong to us.' + x"010000000001003aced6a481653aa534b2f679122e0179de056dbef47442b8c3a1a810dbdfa71049f53cab6e82362800c1558d44993fa6e958a75bd6e6a3472dd278e900041e29010000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f030000000000000000000000000000000000000000000000000000000000000bb80bc9c77af025eb7f73940ad00c9d6f06d45253339a110b0f9ff03b822e5877d30015381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f4090015000000000000000000000000000000000000000000000000000000000badc0de416c6c20796f75722062617365206172652062656c6f6e6720746f2075732e" + } + + public fun encoded_transfer_vaa_wrapped_12_with_fee(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000beefface', + // tokenChain: 2, + // toAddress: '0x000000000000000000000000000000000000000000000000000000000000b0b1', + // chain: 21, + // fee: 1000n + x"010000000001005537ca9a981a62823f57a706f3ceab648391fd99a11631296f798aa394ba6aff73540afefad8634ed573c73c5aa9a16e68906321fa6a4c8a488611b933b1f5b1000000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f010000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000beefface0002000000000000000000000000000000000000000000000000000000000000b0b1001500000000000000000000000000000000000000000000000000000000000003e8" + } + + public fun encoded_transfer_vaa_wrapped_12_without_fee(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000beefface', + // tokenChain: 2, + // toAddress: '0x000000000000000000000000000000000000000000000000000000000000b0b1', + // chain: 21, + // fee: 0n + x"01000000000100e5558a2955f94fdb174d7868c9f643700174949ac72b90f803bdbea00453ed4c426c055b956060c905189cb710b97916af6a77cd3168f83eca9c66b6366c85c4000000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f010000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000beefface0002000000000000000000000000000000000000000000000000000000000000b0b100150000000000000000000000000000000000000000000000000000000000000000" + } + + public fun encoded_transfer_with_payload_wrapped_12(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000beefface', + // tokenChain: 2, + // toAddress: '0x381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f409', + // chain: 21, + // fromAddress: '0x000000000000000000000000000000000000000000000000000000000badc0de', + // payload: 'All your base are belong to us.' + x"0100000000010054968c9be4059d7dc373fff8e80dfc9083c485663517534807d61d11abec64896c4185a2bdd71e3caa713d082c78f5d8b1586c56bd5042dfaba1de0ca0d978a0010000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f030000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000beefface0002381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f4090015000000000000000000000000000000000000000000000000000000000badc0de416c6c20796f75722062617365206172652062656c6f6e6720746f2075732e" + } + + public fun encoded_transfer_vaa_wrapped_7_with_fee(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000deafface', + // tokenChain: 2, + // toAddress: '0x000000000000000000000000000000000000000000000000000000000000b0b1', + // chain: 21, + // fee: 1000n + x"01000000000100b9dc34e110e4268ac1e0ef729513083d45b59e0c2cbee8f9fd7d7d2ed900c8ad2a5ca55310fb3741bf3ff8c611e37a2fee2852e09feb491261edf53fcc956edf010000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f010000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000deafface0002000000000000000000000000000000000000000000000000000000000000b0b1001500000000000000000000000000000000000000000000000000000000000003e8" + } + + public fun encoded_transfer_vaa_wrapped_7_without_fee(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000deafface', + // tokenChain: 2, + // toAddress: '0x000000000000000000000000000000000000000000000000000000000000b0b1', + // chain: 21, + // fee: 0n + x"01000000000100389f0544dc2d3f7095d4e9543ae9f6cb5c9dd6a561e95ed896c870907fe85a94373a455acac8d2ad66154df1cb19ba4ae6c583a1c2839971e6760ecaa1d9fca7000000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f010000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000deafface0002000000000000000000000000000000000000000000000000000000000000b0b100150000000000000000000000000000000000000000000000000000000000000000" + } + + public fun encoded_transfer_vaa_wrapped_12_invalid_target_chain(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000beefface', + // tokenChain: 2, + // toAddress: '0x000000000000000000000000000000000000000000000000000000000000b0b1', + // chain: 69, + // fee: 0n + x"010000000001009c0b89b21622bde003f8e775daffe343e65d6a537719bc977c85b0b18c26751c7bff61077e74711dfe865d935fa840a7352d7a1ccbcec4be77bfc591cd265a48000000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f010000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000beefface0002000000000000000000000000000000000000000000000000000000000000b0b1004500000000000000000000000000000000000000000000000000000000000003e8" + } + + public fun encoded_transfer_with_payload_wrapped_12_invalid_target_chain(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000beefface', + // tokenChain: 2, + // toAddress: '0x381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f409', + // chain: 21, + // fromAddress: '0x000000000000000000000000000000000000000000000000000000000badc0de', + // payload: 'All your base are belong to us.' + x"01000000000100b139a7dbb747b04509ae4f511080a9cb080e423d8db086d5c7553baed2d6151e3fbdd00e691d82662b8d1ed49ec374dba5f82e82df20921151da4b948ddce41e000000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f030000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000beefface0002381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f4090045000000000000000000000000000000000000000000000000000000000badc0de416c6c20796f75722062617365206172652062656c6f6e6720746f2075732e" + } + + public fun encoded_register_chain_2(): vector { + x"0100000000010015d405c74be6d93c3c33ed6b48d8db70dfb31e0981f8098b2a6c7583083e0c3343d4a1abeb3fc1559674fa067b0c0e2e9de2fafeaecdfeae132de2c33c9d27cc0100000001000000010001000000000000000000000000000000000000000000000000000000000000000400000000016911ae00000000000000000000000000000000000000000000546f6b656e427269646765010000000200000000000000000000000000000000000000000000000000000000deadbeef" + } + + public fun encoded_asset_meta_vaa_foreign_12(): vector { + x"0100000000010080366065746148420220f25a6275097370e8db40984529a6676b7a5fc9feb11755ec49ca626b858ddfde88d15601f85ab7683c5f161413b0412143241c700aff010000000100000001000200000000000000000000000000000000000000000000000000000000deadbeef000000000150eb23000200000000000000000000000000000000000000000000000000000000beefface00020c424545460000000000000000000000000000000000000000000000000000000042656566206661636520546f6b656e0000000000000000000000000000000000" + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/token_bridge_scenario.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/token_bridge_scenario.move new file mode 100644 index 0000000000..fab2145773 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/test/token_bridge_scenario.move @@ -0,0 +1,136 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +module token_bridge::token_bridge_scenario { + use std::vector::{Self}; + use iota::balance::{Self}; + use iota::package::{UpgradeCap}; + use iota::test_scenario::{Self, Scenario}; + use wormhole::external_address::{Self}; + use wormhole::wormhole_scenario::{ + deployer, + return_state as return_wormhole_state, + set_up_wormhole, + take_state as take_wormhole_state + }; + + use token_bridge::native_asset::{Self}; + use token_bridge::setup::{Self, DeployerCap}; + use token_bridge::state::{Self, State}; + use token_bridge::token_registry::{Self}; + + public fun set_up_wormhole_and_token_bridge( + scenario: &mut Scenario, + wormhole_fee: u64 + ) { + // init and share wormhole core bridge + set_up_wormhole(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, deployer()); + + // Publish Token Bridge. + setup::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, deployer()); + + let wormhole_state = take_wormhole_state(scenario); + + let upgrade_cap = + test_scenario::take_from_sender(scenario); + let emitter_cap = + wormhole::emitter::new( + &wormhole_state, + test_scenario::ctx(scenario) + ); + let governance_chain = 1; + let governance_contract = + x"0000000000000000000000000000000000000000000000000000000000000004"; + + // Finally share `State`. + setup::complete( + test_scenario::take_from_sender(scenario), + upgrade_cap, + emitter_cap, + governance_chain, + governance_contract, + test_scenario::ctx(scenario) + ); + + // Clean up. + return_wormhole_state(wormhole_state); + } + + /// Perform an upgrade (which just upticks the current version of what the + /// `State` believes is true). + public fun upgrade_token_bridge(scenario: &mut Scenario) { + // Clean up from activity prior. + test_scenario::next_tx(scenario, person()); + + let token_bridge_state = take_state(scenario); + state::test_upgrade(&mut token_bridge_state); + + // Clean up. + return_state(token_bridge_state); + } + + /// Register arbitrary chain ID with the same emitter address (0xdeadbeef). + public fun register_dummy_emitter(scenario: &mut Scenario, chain: u16) { + // Ignore effects. + test_scenario::next_tx(scenario, person()); + + let token_bridge_state = take_state(scenario); + token_bridge::register_chain::register_new_emitter_test_only( + &mut token_bridge_state, + chain, + external_address::from_address(@0xdeadbeef) + ); + + // Clean up. + return_state(token_bridge_state); + } + + /// Register 0xdeadbeef for multiple chains. + public fun register_dummy_emitters( + scenario: &mut Scenario, + chains: vector + ) { + while (!vector::is_empty(&chains)) { + register_dummy_emitter(scenario, vector::pop_back(&mut chains)); + }; + vector::destroy_empty(chains); + } + + public fun deposit_native( + token_bridge_state: &mut State, + deposit_amount: u64 + ) { + native_asset::deposit_test_only( + token_registry::borrow_mut_native_test_only( + state::borrow_mut_token_registry_test_only(token_bridge_state) + ), + balance::create_for_testing(deposit_amount) + ) + } + + public fun person(): address { + wormhole::wormhole_scenario::person() + } + + public fun two_people(): (address, address) { + wormhole::wormhole_scenario::two_people() + } + + public fun three_people(): (address, address, address) { + wormhole::wormhole_scenario::three_people() + } + + public fun take_state(scenario: &Scenario): State { + test_scenario::take_shared(scenario) + } + + public fun return_state(token_bridge_state: State) { + test_scenario::return_shared(token_bridge_state); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/transfer_tokens.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/transfer_tokens.move new file mode 100644 index 0000000000..0fbdb5ddc6 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/transfer_tokens.move @@ -0,0 +1,1053 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements three methods: `prepare_transfer` and +/// `transfer_tokens`, which are meant to work together. +/// +/// `prepare_transfer` allows a contract to pack token transfer parameters in +/// preparation to bridge these assets to another network. Anyone can call this +/// method to create `TransferTicket`. +/// +/// `transfer_tokens` unpacks the `TransferTicket` and constructs a +/// `MessageTicket`, which will be used by Wormhole's `publish_message` +/// module. +/// +/// The purpose of splitting this token transferring into two steps is in case +/// Token Bridge needs to be upgraded and there is a breaking change for this +/// module, an integrator would not be left broken. It is discouraged to put +/// `transfer_tokens` in an integrator's package logic. Otherwise, this +/// integrator needs to be prepared to upgrade his contract to handle the latest +/// version of `transfer_tokens`. +/// +/// Instead, an integrator is encouraged to execute a transaction block, which +/// executes `transfer_tokens` using the latest Token Bridge package ID and to +/// implement `prepare_transfer` in his contract to produce `PrepareTransfer`. +/// +/// NOTE: Only assets that exist in the `TokenRegistry` can be bridged out, +/// which are native Iota assets that have been attested for via `attest_token` +/// and wrapped foreign assets that have been created using foreign asset +/// metadata via the `create_wrapped` module. +/// +/// See `transfer` module for serialization and deserialization of Wormhole +/// message payload. +module token_bridge::transfer_tokens { + use iota::balance::{Self, Balance}; + use iota::coin::{Self, Coin}; + use wormhole::bytes32::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + use wormhole::publish_message::{MessageTicket}; + + use token_bridge::native_asset::{Self}; + use token_bridge::normalized_amount::{Self, NormalizedAmount}; + use token_bridge::state::{Self, State, LatestOnly}; + use token_bridge::token_registry::{Self, VerifiedAsset}; + use token_bridge::transfer::{Self}; + use token_bridge::wrapped_asset::{Self}; + + friend token_bridge::transfer_tokens_with_payload; + + /// Relayer fee exceeds `Coin` object's value. + const E_RELAYER_FEE_EXCEEDS_AMOUNT: u64 = 0; + + /// This type represents transfer data for a recipient on a foreign chain. + /// The only way to destroy this type is calling `transfer_tokens`. + /// + /// NOTE: An integrator that expects to bridge assets between his contracts + /// should probably use the `transfer_tokens_with_payload` module, which + /// expects a specific redeemer to complete the transfer (transfers sent + /// using `transfer_tokens` can be redeemed by anyone on behalf of the + /// encoded recipient). + struct TransferTicket { + asset_info: VerifiedAsset, + bridged_in: Balance, + norm_amount: NormalizedAmount, + recipient_chain: u16, + recipient: vector, + relayer_fee: u64, + nonce: u32 + } + + /// `prepare_transfer` constructs token transfer parameters. Any remaining + /// amount (A.K.A. dust) from the funds provided will be returned along with + /// the `TransferTicket` type. The returned coin object is the same object + /// moved into this method. + /// + /// NOTE: Integrators of Token Bridge should be calling only this method + /// from their contracts. This method is not guarded by version control + /// (thus not requiring a reference to the Token Bridge `State` object), so + /// it is intended to work for any package version. + public fun prepare_transfer( + asset_info: VerifiedAsset, + funded: Coin, + recipient_chain: u16, + recipient: vector, + relayer_fee: u64, + nonce: u32 + ): ( + TransferTicket, + Coin + ) { + let ( + bridged_in, + norm_amount + ) = take_truncated_amount(&asset_info, &mut funded); + + let ticket = + TransferTicket { + asset_info, + bridged_in, + norm_amount, + relayer_fee, + recipient_chain, + recipient, + nonce + }; + + // The remaining amount of funded may have dust depending on the + // decimals of this asset. + (ticket, funded) + } + + /// `transfer_tokens` is the only method that can unpack the members of + /// `TransferTicket`. This method takes the balance from this type and + /// bridges this asset out of Iota by either joining its balance in the Token + /// Bridge's custody for native assets or burning its balance for wrapped + /// assets. + /// + /// A `relayer_fee` of some value less than or equal to the bridged balance + /// can be specified to incentivize someone to redeem this transfer on + /// behalf of the `recipient`. + /// + /// This method returns the prepared Wormhole message (which should be + /// consumed by calling `publish_message` in a transaction block). + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + /// + /// It is important for integrators to refrain from calling this method + /// within their contracts. This method is meant to be called in a + /// transaction block after receiving a `TransferTicket` from calling + /// `prepare_transfer` within a contract. If in a circumstance where this + /// module has a breaking change in an upgrade, `prepare_transfer` will not + /// be affected by this change. + public fun transfer_tokens( + token_bridge_state: &mut State, + ticket: TransferTicket + ): MessageTicket { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + let ( + nonce, + encoded_transfer + ) = + bridge_in_and_serialize_transfer( + &latest_only, + token_bridge_state, + ticket + ); + + // Prepare Wormhole message with encoded `Transfer`. + state::prepare_wormhole_message( + &latest_only, + token_bridge_state, + nonce, + encoded_transfer + ) + } + + /// Modify coin based on the decimals of a given coin type, which may + /// leave some amount if the decimals lead to truncating the coin's balance. + /// This method returns the extracted balance (which will be bridged out of + /// Iota) and the normalized amount, which will be encoded in the token + /// transfer payload. + /// + /// NOTE: This is a privileged method, which only this and the + /// `transfer_tokens_with_payload` modules can use. + public(friend) fun take_truncated_amount( + asset_info: &VerifiedAsset, + funded: &mut Coin + ): ( + Balance, + NormalizedAmount + ) { + // Calculate dust. If there is any, `bridged_in` will have remaining + // value after split. `norm_amount` is copied since it is denormalized + // at this step. + let decimals = token_registry::coin_decimals(asset_info); + let norm_amount = + normalized_amount::from_raw(coin::value(funded), decimals); + + // Split the `bridged_in` coin object to return any dust remaining on + // that object. Only bridge in the adjusted amount after de-normalizing + // the normalized amount. + let truncated = + balance::split( + coin::balance_mut(funded), + normalized_amount::to_raw(norm_amount, decimals) + ); + + (truncated, norm_amount) + } + + /// For a given coin type, either burn Token Bridge wrapped assets or + /// deposit coin into Token Bridge's custody. This method returns the + /// canonical token info (chain ID and address), which will be encoded in + /// the token transfer. + /// + /// NOTE: This is a privileged method, which only this and the + /// `transfer_tokens_with_payload` modules can use. + public(friend) fun burn_or_deposit_funds( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + asset_info: &VerifiedAsset, + bridged_in: Balance + ): ( + u16, + ExternalAddress + ) { + // Either burn or deposit depending on `CoinType`. + let registry = + state::borrow_mut_token_registry(latest_only, token_bridge_state); + if (token_registry::is_wrapped(asset_info)) { + wrapped_asset::burn( + token_registry::borrow_mut_wrapped(registry), + bridged_in + ); + } else { + native_asset::deposit( + token_registry::borrow_mut_native(registry), + bridged_in + ); + }; + + // Return canonical token info. + ( + token_registry::token_chain(asset_info), + token_registry::token_address(asset_info) + ) + } + + fun bridge_in_and_serialize_transfer( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + ticket: TransferTicket + ): ( + u32, + vector + ) { + let TransferTicket { + asset_info, + bridged_in, + norm_amount, + recipient_chain, + recipient, + relayer_fee, + nonce + } = ticket; + + // Disallow `relayer_fee` to be greater than the `Coin` object's value. + // Keep in mind that the relayer fee is evaluated against the truncated + // amount. + let amount = iota::balance::value(&bridged_in); + assert!(relayer_fee <= amount, E_RELAYER_FEE_EXCEEDS_AMOUNT); + + // Handle funds and get canonical token info for encoded transfer. + let ( + token_chain, + token_address + ) = burn_or_deposit_funds( + latest_only, + token_bridge_state, + &asset_info, bridged_in + ); + + // Ensure that the recipient is a 32-byte address. + let recipient = external_address::new(bytes32::from_bytes(recipient)); + + // Finally encode `Transfer`. + let encoded = + transfer::serialize( + transfer::new( + norm_amount, + token_address, + token_chain, + recipient, + recipient_chain, + normalized_amount::from_raw( + relayer_fee, + token_registry::coin_decimals(&asset_info) + ) + ) + ); + + (nonce, encoded) + } + + #[test_only] + public fun bridge_in_and_serialize_transfer_test_only( + token_bridge_state: &mut State, + ticket: TransferTicket + ): ( + u32, + vector + ) { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + bridge_in_and_serialize_transfer( + &latest_only, + token_bridge_state, + ticket + ) + } +} + +#[test_only] +module token_bridge::transfer_token_tests { + use iota::coin::{Self}; + use iota::test_scenario::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::external_address::{Self}; + use wormhole::publish_message::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::coin_wrapped_7::{Self, COIN_WRAPPED_7}; + use token_bridge::native_asset::{Self}; + use token_bridge::normalized_amount::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + set_up_wormhole_and_token_bridge, + register_dummy_emitter, + return_state, + take_state, + person + }; + use token_bridge::token_registry::{Self}; + use token_bridge::transfer::{Self}; + use token_bridge::transfer_tokens::{Self}; + use token_bridge::wrapped_asset::{Self}; + + /// Test consts. + const TEST_TARGET_RECIPIENT: vector = x"beef4269"; + const TEST_TARGET_CHAIN: u16 = 2; + const TEST_NONCE: u32 = 0; + const TEST_COIN_NATIVE_10_DECIMALS: u8 = 10; + const TEST_COIN_WRAPPED_7_DECIMALS: u8 = 7; + + #[test] + fun test_transfer_tokens_native_10() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let coin_10_balance = + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 100000; + + // Balance check the Token Bridge before executing the transfer. The + // initial balance should be zero for COIN_NATIVE_10. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == 0, 0); + }; + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Call `transfer_tokens`. + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Balance check the Token Bridge after executing the transfer. The + // balance should now reflect the `transfer_amount` defined in this + // test. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == transfer_amount, 0); + }; + + // Clean up. + publish_message::destroy(prepared_msg); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_transfer_tokens_native_10_with_dust_refund() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 1000069; + let coin_10_balance = + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // This value will be used later. The contract should return dust + // to the caller since COIN_NATIVE_10 has 10 decimals. + let expected_dust = 69; + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 100000; + + // Balance check the Token Bridge before executing the transfer. The + // initial balance should be zero for COIN_NATIVE_10. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == 0, 0); + }; + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + assert!(coin::value(&dust) == expected_dust, 0); + + // Call `transfer_tokens`. + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Balance check the Token Bridge after executing the transfer. The + // balance should now reflect the `transfer_amount` less `expected_dust` + // defined in this test. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!( + native_asset::custody(asset) == transfer_amount - expected_dust, + 0 + ); + }; + + // Clean up. + publish_message::destroy(prepared_msg); + coin::burn_for_testing(dust); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_serialize_transfer_tokens_native_10() { + use token_bridge::transfer_tokens::{ + bridge_in_and_serialize_transfer_test_only, + prepare_transfer + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let bridged_coin_10 = + coin::from_balance( + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ), + test_scenario::ctx(scenario) + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 100000; + + let asset_info = state::verified_asset(&token_bridge_state); + let expected_token_address = token_registry::token_address(&asset_info); + + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + bridged_coin_10, + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Call `transfer_tokens`. + let ( + nonce, + payload + ) = + bridge_in_and_serialize_transfer_test_only( + &mut token_bridge_state, + ticket + ); + assert!(nonce == TEST_NONCE, 0); + + // Construct expected payload from scratch and confirm that the + // `transfer_tokens` call produces the same payload. + let expected_amount = + normalized_amount::from_raw( + transfer_amount, + TEST_COIN_NATIVE_10_DECIMALS + ); + let expected_relayer_fee = + normalized_amount::from_raw( + relayer_fee, + TEST_COIN_NATIVE_10_DECIMALS + ); + + let expected_payload = + transfer::new_test_only( + expected_amount, + expected_token_address, + chain_id(), + external_address::new( + bytes32::from_bytes(TEST_TARGET_RECIPIENT) + ), + TEST_TARGET_CHAIN, + expected_relayer_fee + ); + assert!(transfer::serialize_test_only(expected_payload) == payload, 0); + + // Clean up. + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_transfer_tokens_wrapped_7() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 42069000; + let coin_7_balance = + coin_wrapped_7::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 100000; + + // Balance check the Token Bridge before executing the transfer. The + // initial balance should be the `transfer_amount` for COIN_WRAPPED_7. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == transfer_amount, 0); + }; + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + coin::from_balance( + coin_7_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Call `transfer_tokens`. + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Balance check the Token Bridge after executing the transfer. The + // balance should be zero, since tokens are burned when an outbound + // wrapped token transfer occurs. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == 0, 0); + }; + + // Clean up. + publish_message::destroy(prepared_msg); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_serialize_transfer_tokens_wrapped_7() { + use token_bridge::transfer_tokens::{ + bridge_in_and_serialize_transfer_test_only, + prepare_transfer + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let bridged_coin_7 = + coin::from_balance( + coin_wrapped_7::init_register_and_mint( + scenario, + sender, + transfer_amount + ), + test_scenario::ctx(scenario) + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 100000; + + let asset_info = state::verified_asset(&token_bridge_state); + let expected_token_address = token_registry::token_address(&asset_info); + let expected_token_chain = token_registry::token_chain(&asset_info); + + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + bridged_coin_7, + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Call `transfer_tokens`. + let ( + nonce, + payload + ) = + bridge_in_and_serialize_transfer_test_only( + &mut token_bridge_state, + ticket + ); + assert!(nonce == TEST_NONCE, 0); + + // Construct expected payload from scratch and confirm that the + // `transfer_tokens` call produces the same payload. + let expected_amount = + normalized_amount::from_raw( + transfer_amount, + TEST_COIN_WRAPPED_7_DECIMALS + ); + let expected_relayer_fee = + normalized_amount::from_raw( + relayer_fee, + TEST_COIN_WRAPPED_7_DECIMALS + ); + + let expected_payload = + transfer::new_test_only( + expected_amount, + expected_token_address, + expected_token_chain, + external_address::new( + bytes32::from_bytes(TEST_TARGET_RECIPIENT) + ), + TEST_TARGET_CHAIN, + expected_relayer_fee + ); + assert!(transfer::serialize_test_only(expected_payload) == payload, 0); + + // Clean up. + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = token_registry::E_UNREGISTERED)] + fun test_cannot_transfer_tokens_native_not_registered() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Initialize COIN_NATIVE_10 (but don't register it). + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // NOTE: This test purposely doesn't `attest` COIN_NATIVE_10. + let transfer_amount = 6942000; + let test_coins = + coin::mint_for_testing( + transfer_amount, + test_scenario::ctx(scenario) + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 100000; + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + test_coins, + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // You shall not pass! + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Clean up. + publish_message::destroy(prepared_msg); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = token_registry::E_UNREGISTERED)] + fun test_cannot_transfer_tokens_wrapped_not_registered() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Initialize COIN_WRAPPED_7 (but don't register it). + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + let treasury_cap = + coin_wrapped_7::init_and_take_treasury_cap( + scenario, + sender + ); + iota::test_utils::destroy(treasury_cap); + + // NOTE: This test purposely doesn't `attest` COIN_WRAPPED_7. + let transfer_amount = 42069; + let test_coins = + coin::mint_for_testing( + transfer_amount, + test_scenario::ctx(scenario) + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 1000; + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + test_coins, + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // You shall not pass! + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Clean up. + publish_message::destroy(prepared_msg); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = transfer_tokens::E_RELAYER_FEE_EXCEEDS_AMOUNT + )] + fun test_cannot_transfer_tokens_fee_exceeds_amount() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // NOTE: The `relayer_fee` is intentionally set to a higher number + // than the `transfer_amount`. + let relayer_fee = 100001; + let transfer_amount = 100000; + let coin_10_balance = + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // You shall not pass! + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Done. + publish_message::destroy(prepared_msg); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_transfer_tokens_outdated_version() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let coin_10_balance = + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + let asset_info = state::verified_asset(&token_bridge_state); + + let relayer_fee = 0; + + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Clean up. + publish_message::destroy(prepared_msg); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/transfer_tokens_with_payload.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/transfer_tokens_with_payload.move new file mode 100644 index 0000000000..48fca22f47 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/transfer_tokens_with_payload.move @@ -0,0 +1,812 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements three methods: `prepare_transfer` and +/// `transfer_tokens_with_payload`, which are meant to work together. +/// +/// `prepare_transfer` allows a contract to pack token transfer parameters with +/// an arbitrary payload in preparation to bridge these assets to another +/// network. Only an `EmitterCap` has the capability to create +/// `TransferTicket`. The `EmitterCap` object ID is encoded as the +/// sender. +/// +/// `transfer_tokens_with_payload` unpacks the `TransferTicket` and +/// constructs a `MessageTicket`, which will be used by Wormhole's +/// `publish_message` module. +/// +/// The purpose of splitting this token transferring into two steps is in case +/// Token Bridge needs to be upgraded and there is a breaking change for this +/// module, an integrator would not be left broken. It is discouraged to put +/// `transfer_tokens_with_payload` in an integrator's package logic. Otherwise, +/// this integrator needs to be prepared to upgrade his contract to handle the +/// latest version of `transfer_tokens_with_payload`. +/// +/// Instead, an integrator is encouraged to execute a transaction block, which +/// executes `transfer_tokens_with_payload` using the latest Token Bridge +/// package ID and to implement `prepare_transfer` in his contract to produce +/// `PrepareTransferWithPayload`. +/// +/// NOTE: Only assets that exist in the `TokenRegistry` can be bridged out, +/// which are native Iota assets that have been attested for via `attest_token` +/// and wrapped foreign assets that have been created using foreign asset +/// metadata via the `create_wrapped` module. +/// +/// See `transfer_with_payload` module for serialization and deserialization of +/// Wormhole message payload. +module token_bridge::transfer_tokens_with_payload { + use iota::balance::{Balance}; + use iota::coin::{Coin}; + use iota::object::{Self, ID}; + use wormhole::bytes32::{Self}; + use wormhole::emitter::{EmitterCap}; + use wormhole::external_address::{Self}; + use wormhole::publish_message::{MessageTicket}; + + use token_bridge::normalized_amount::{NormalizedAmount}; + use token_bridge::state::{Self, State, LatestOnly}; + use token_bridge::token_registry::{VerifiedAsset}; + use token_bridge::transfer_with_payload::{Self}; + + /// This type represents transfer data for a specific redeemer contract on a + /// foreign chain. The only way to destroy this type is calling + /// `transfer_tokens_with_payload`. Only the owner of an `EmitterCap` has + /// the capability of generating `TransferTicket`. This emitter + /// cap will usually live in an integrator's contract storage object. + struct TransferTicket { + asset_info: VerifiedAsset, + bridged_in: Balance, + norm_amount: NormalizedAmount, + sender: ID, + redeemer_chain: u16, + redeemer: vector, + payload: vector, + nonce: u32 + } + + /// `prepare_transfer` constructs token transfer parameters. Any remaining + /// amount (A.K.A. dust) from the funds provided will be returned along with + /// the `TransferTicket` type. The returned coin object is the + /// same object moved into this method. + /// + /// NOTE: Integrators of Token Bridge should be calling only this method + /// from their contracts. This method is not guarded by version control + /// (thus not requiring a reference to the Token Bridge `State` object), so + /// it is intended to work for any package version. + public fun prepare_transfer( + emitter_cap: &EmitterCap, + asset_info: VerifiedAsset, + funded: Coin, + redeemer_chain: u16, + redeemer: vector, + payload: vector, + nonce: u32 + ): ( + TransferTicket, + Coin + ) { + use token_bridge::transfer_tokens::{take_truncated_amount}; + + let ( + bridged_in, + norm_amount + ) = take_truncated_amount(&asset_info, &mut funded); + + let prepared_transfer = + TransferTicket { + asset_info, + bridged_in, + norm_amount, + sender: object::id(emitter_cap), + redeemer_chain, + redeemer, + payload, + nonce + }; + + // The remaining amount of funded may have dust depending on the + // decimals of this asset. + (prepared_transfer, funded) + } + + /// `transfer_tokens_with_payload` is the only method that can unpack the + /// members of `TransferTicket`. This method takes the balance + /// from this type and bridges this asset out of Iota by either joining its + /// balance in the Token Bridge's custody for native assets or burning its + /// balance for wrapped assets. + /// + /// The unpacked sender ID comes from an `EmitterCap`. It is encoded as the + /// sender of these assets. And associated with this transfer is an + /// arbitrary payload, which can be consumed by the specified redeemer and + /// used as instructions for a contract composing with Token Bridge. + /// + /// This method returns the prepared Wormhole message (which should be + /// consumed by calling `publish_message` in a transaction block). + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + /// + /// It is important for integrators to refrain from calling this method + /// within their contracts. This method is meant to be called in a + /// transaction block after receiving a `TransferTicket` from calling + /// `prepare_transfer` within a contract. If in a circumstance where this + /// module has a breaking change in an upgrade, `prepare_transfer` will not + /// be affected by this change. + public fun transfer_tokens_with_payload( + token_bridge_state: &mut State, + prepared_transfer: TransferTicket + ): MessageTicket { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // Encode Wormhole message payload. + let ( + nonce, + encoded_transfer_with_payload + ) = + bridge_in_and_serialize_transfer( + &latest_only, + token_bridge_state, + prepared_transfer + ); + + // Prepare Wormhole message with encoded `TransferWithPayload`. + state::prepare_wormhole_message( + &latest_only, + token_bridge_state, + nonce, + encoded_transfer_with_payload + ) + } + + fun bridge_in_and_serialize_transfer( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + prepared_transfer: TransferTicket + ): ( + u32, + vector + ) { + use token_bridge::transfer_tokens::{burn_or_deposit_funds}; + + let TransferTicket { + asset_info, + bridged_in, + norm_amount, + sender, + redeemer_chain, + redeemer, + payload, + nonce + } = prepared_transfer; + + let ( + token_chain, + token_address + ) = + burn_or_deposit_funds( + latest_only, + token_bridge_state, + &asset_info, + bridged_in + ); + + let redeemer = external_address::new(bytes32::from_bytes(redeemer)); + + let encoded = + transfer_with_payload::serialize( + transfer_with_payload::new( + sender, + norm_amount, + token_address, + token_chain, + redeemer, + redeemer_chain, + payload + ) + ); + + (nonce, encoded) + } + + #[test_only] + public fun bridge_in_and_serialize_transfer_test_only( + token_bridge_state: &mut State, + prepared_transfer: TransferTicket + ): ( + u32, + vector + ) { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + bridge_in_and_serialize_transfer( + &latest_only, + token_bridge_state, + prepared_transfer + ) + } +} + +#[test_only] +module token_bridge::transfer_tokens_with_payload_tests { + use iota::coin::{Self}; + use iota::object::{Self}; + use iota::test_scenario::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::emitter::{Self}; + use wormhole::external_address::{Self}; + use wormhole::publish_message::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::coin_wrapped_7::{Self, COIN_WRAPPED_7}; + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::native_asset::{Self}; + use token_bridge::normalized_amount::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + set_up_wormhole_and_token_bridge, + register_dummy_emitter, + return_state, + take_state, + person + }; + use token_bridge::token_registry::{Self}; + use token_bridge::transfer_with_payload::{Self}; + use token_bridge::wrapped_asset::{Self}; + + /// Test consts. + const TEST_TARGET_RECIPIENT: vector = x"beef4269"; + const TEST_TARGET_CHAIN: u16 = 2; + const TEST_NONCE: u32 = 0; + const TEST_COIN_NATIVE_10_DECIMALS: u8 = 10; + const TEST_COIN_WRAPPED_7_DECIMALS: u8 = 7; + const TEST_MESSAGE_PAYLOAD: vector = x"deadbeefdeadbeef"; + + #[test] + fun test_transfer_tokens_with_payload_native_10() { + use token_bridge::transfer_tokens_with_payload::{ + prepare_transfer, + transfer_tokens_with_payload + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let coin_10_balance = + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Balance check the Token Bridge before executing the transfer. The + // initial balance should be zero for COIN_NATIVE_10. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == 0, 0); + }; + + // Register and obtain a new wormhole emitter cap. + let emitter_cap = emitter::dummy(); + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + prepared_transfer, + dust + ) = + prepare_transfer( + &emitter_cap, + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + TEST_MESSAGE_PAYLOAD, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Call `transfer_tokens_with_payload`. + let prepared_msg = + transfer_tokens_with_payload( + &mut token_bridge_state, + prepared_transfer + ); + + // Balance check the Token Bridge after executing the transfer. The + // balance should now reflect the `transfer_amount` defined in this + // test. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == transfer_amount, 0); + }; + + // Clean up. + publish_message::destroy(prepared_msg); + return_state(token_bridge_state); + emitter::destroy_test_only(emitter_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_transfer_tokens_native_10_with_dust_refund() { + use token_bridge::transfer_tokens_with_payload::{ + prepare_transfer, + transfer_tokens_with_payload + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 1000069; + let coin_10_balance = coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // This value will be used later. The contract should return dust + // to the caller since COIN_NATIVE_10 has 10 decimals. + let expected_dust = 69; + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Balance check the Token Bridge before executing the transfer. The + // initial balance should be zero for COIN_NATIVE_10. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == 0, 0); + }; + + // Register and obtain a new wormhole emitter cap. + let emitter_cap = emitter::dummy(); + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + prepared_transfer, + dust + ) = + prepare_transfer( + &emitter_cap, + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + TEST_MESSAGE_PAYLOAD, + TEST_NONCE, + ); + assert!(coin::value(&dust) == expected_dust, 0); + + // Call `transfer_tokens`. + let prepared_msg = + transfer_tokens_with_payload( + &mut token_bridge_state, + prepared_transfer + ); + + // Balance check the Token Bridge after executing the transfer. The + // balance should now reflect the `transfer_amount` less `expected_dust` + // defined in this test. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!( + native_asset::custody(asset) == transfer_amount - expected_dust, + 0 + ); + }; + + // Clean up. + publish_message::destroy(prepared_msg); + coin::burn_for_testing(dust); + emitter::destroy_test_only(emitter_cap); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_serialize_transfer_tokens_native_10() { + use token_bridge::transfer_tokens_with_payload::{ + bridge_in_and_serialize_transfer_test_only, + prepare_transfer + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let bridge_coin_10 = + coin::from_balance( + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ), + test_scenario::ctx(scenario) + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Register and obtain a new wormhole emitter cap. + let emitter_cap = emitter::dummy(); + + let asset_info = state::verified_asset(&token_bridge_state); + let expected_token_address = token_registry::token_address(&asset_info); + + let ( + prepared_transfer, + dust + ) = + prepare_transfer( + &emitter_cap, + asset_info, + bridge_coin_10, + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + TEST_MESSAGE_PAYLOAD, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Serialize the payload. + let ( + nonce, + payload + ) = + bridge_in_and_serialize_transfer_test_only( + &mut token_bridge_state, + prepared_transfer + ); + assert!(nonce == TEST_NONCE, 0); + + // Construct expected payload from scratch and confirm that the + // `transfer_tokens` call produces the same payload. + let expected_amount = normalized_amount::from_raw( + transfer_amount, + TEST_COIN_NATIVE_10_DECIMALS + ); + + let expected_payload = + transfer_with_payload::new_test_only( + object::id(&emitter_cap), + expected_amount, + expected_token_address, + chain_id(), + external_address::new(bytes32::from_bytes(TEST_TARGET_RECIPIENT)), + TEST_TARGET_CHAIN, + TEST_MESSAGE_PAYLOAD + ); + assert!( + transfer_with_payload::serialize(expected_payload) == payload, + 0 + ); + + // Clean up. + return_state(token_bridge_state); + emitter::destroy_test_only(emitter_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_transfer_tokens_with_payload_wrapped_7() { + use token_bridge::transfer_tokens_with_payload::{ + prepare_transfer, + transfer_tokens_with_payload + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let coin_7_balance = + coin_wrapped_7::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Balance check the Token Bridge before executing the transfer. The + // initial balance should be the `transfer_amount` for COIN_WRAPPED_7. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == transfer_amount, 0); + }; + + // Register and obtain a new wormhole emitter cap. + let emitter_cap = emitter::dummy(); + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + prepared_transfer, + dust + ) = + prepare_transfer( + &emitter_cap, + asset_info, + coin::from_balance( + coin_7_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + TEST_MESSAGE_PAYLOAD, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Call `transfer_tokens_with_payload`. + let prepared_msg = + transfer_tokens_with_payload( + &mut token_bridge_state, + prepared_transfer + ); + + // Balance check the Token Bridge after executing the transfer. The + // balance should be zero, since tokens are burned when an outbound + // wrapped token transfer occurs. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == 0, 0); + }; + + // Clean up. + publish_message::destroy(prepared_msg); + emitter::destroy_test_only(emitter_cap); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_serialize_transfer_tokens_wrapped_7() { + use token_bridge::transfer_tokens_with_payload::{ + bridge_in_and_serialize_transfer_test_only, + prepare_transfer + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let bridged_coin_7 = + coin::from_balance( + coin_wrapped_7::init_register_and_mint( + scenario, + sender, + transfer_amount + ), + test_scenario::ctx(scenario) + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Register and obtain a new wormhole emitter cap. + let emitter_cap = emitter::dummy(); + + let asset_info = state::verified_asset(&token_bridge_state); + let expected_token_address = token_registry::token_address(&asset_info); + let expected_token_chain = token_registry::token_chain(&asset_info); + + let ( + prepared_transfer, + dust + ) = + prepare_transfer( + &emitter_cap, + asset_info, + bridged_coin_7, + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + TEST_MESSAGE_PAYLOAD, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Serialize the payload. + let ( + nonce, + payload + ) = + bridge_in_and_serialize_transfer_test_only( + &mut token_bridge_state, + prepared_transfer + ); + assert!(nonce == TEST_NONCE, 0); + + // Construct expected payload from scratch and confirm that the + // `transfer_tokens` call produces the same payload. + let expected_amount = normalized_amount::from_raw( + transfer_amount, + TEST_COIN_WRAPPED_7_DECIMALS + ); + + let expected_payload = + transfer_with_payload::new_test_only( + object::id(&emitter_cap), + expected_amount, + expected_token_address, + expected_token_chain, + external_address::new(bytes32::from_bytes(TEST_TARGET_RECIPIENT)), + TEST_TARGET_CHAIN, + TEST_MESSAGE_PAYLOAD + ); + assert!( + transfer_with_payload::serialize(expected_payload) == payload, + 0 + ); + + // Clean up. + emitter::destroy_test_only(emitter_cap); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_transfer_tokens_with_payload_outdated_version() { + use token_bridge::transfer_tokens_with_payload::{ + prepare_transfer, + transfer_tokens_with_payload + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let coin_10_balance = + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Register and obtain a new wormhole emitter cap. + let emitter_cap = emitter::dummy(); + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + prepared_transfer, + dust + ) = + prepare_transfer( + &emitter_cap, + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + TEST_MESSAGE_PAYLOAD, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + let prepared_msg = + transfer_tokens_with_payload( + &mut token_bridge_state, + prepared_transfer + ); + + // Clean up. + publish_message::destroy(prepared_msg); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/utils/coin_utils.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/utils/coin_utils.move new file mode 100644 index 0000000000..4eb94151e5 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/utils/coin_utils.move @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements utilities helpful for outbound token transfers. These +/// utility methods should also help avoid having to work around conversions +/// between `Coin` and `Balance` avoiding unnecessary object creation and +/// destruction. +module token_bridge::coin_utils { + use iota::balance::{Self, Balance}; + use iota::coin::{Self, Coin}; + use iota::tx_context::{TxContext}; + + /// Method similar to `coin::take` where an amount is split from a `Coin` + /// object's inner balance. + public fun take_balance( + coin_mut: &mut Coin, + amount: u64 + ): Balance { + balance::split(coin::balance_mut(coin_mut), amount) + } + + /// Method out of convenience to take the full balance value out of a `Coin` + /// object while preserving that object. This method is used to avoid + /// calling `coin::into_balance` which destroys the object. + public fun take_full_balance(coin_mut: &mut Coin): Balance { + let amount = coin::value(coin_mut); + take_balance(coin_mut, amount) + } + + /// Method similar to `coin::put` where an outside balance is joined with + /// an existing `Coin` object. + public fun put_balance( + coin_mut: &mut Coin, + the_balance: Balance + ): u64 { + balance::join(coin::balance_mut(coin_mut), the_balance) + } + + /// Method for those integrators that use `Coin` objects, where `the_coin` + /// will be destroyed if the value is zero. Otherwise it will be returned + /// back to the transaction sender. + public fun return_nonzero(the_coin: Coin, ctx: &TxContext) { + if (coin::value(&the_coin) == 0) { + coin::destroy_zero(the_coin); + } else { + iota::pay::keep(the_coin, ctx) + } + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/utils/string_utils.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/utils/string_utils.move new file mode 100644 index 0000000000..17a1fbdcdb --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/utils/string_utils.move @@ -0,0 +1,97 @@ +module token_bridge::string_utils { + use std::ascii::{Self}; + use std::string::{Self, String}; + use std::vector::{Self}; + + const QUESTION_MARK: u8 = 63; + // Recall that UTF-8 characters have variable-length encoding and can have + // 1, 2, 3, or 4 bytes. + // The first byte of the 2, 3, and 4-byte UTF-8 characters have a special + // form indicating how many more bytes follow in the same character + // representation. Specifically, it can have the forms + // - 110xxxxx // 11000000 is 192 (base 10) + // - 1110xxxx // 11100000 is 224 (base 10) + // - or 11110xxx // 11110000 is 240 (base 10) + // + // We can tell the length the a hex UTF-8 character in bytes by looking + // at the first byte and counting the leading 1's, or alternatively + // seeing whether it falls in the range + // [11000000, 11100000) or [11100000, 11110000) or [11110000, 11111111], + // + // The following constants demarcate those ranges and are used in the + // string32::to_ascii function. + const UTF8_LENGTH_2_FIRST_BYTE_LOWER_BOUND: u8 = 192; + const UTF8_LENGTH_3_FIRST_BYTE_LOWER_BOUND: u8 = 224; + const UTF8_LENGTH_4_FIRST_BYTE_LOWER_BOUND: u8 = 240; + + /// Converts a String32 to an ascii string if possible, otherwise errors + /// out at `ascii::string(bytes)`. For input strings that contain non-ascii + /// characters, we will swap the non-ascii character with `?`. + /// + /// Note that while the Iota spec limits symbols to only use ascii + /// characters, the token bridge spec does allow utf8 symbols. + public fun to_ascii(s: &String): ascii::String { + let buf = *string::bytes(s); + // keep dropping the last character while it's 0 + while ( + !vector::is_empty(&buf) && + *vector::borrow(&buf, vector::length(&buf) - 1) == 0 + ) { + vector::pop_back(&mut buf); + }; + + // Run through `buf` to convert any non-ascii character to `?`. + let asciified = vector::empty(); + let (i, n) = (0, vector::length(&buf)); + while (i < n) { + let b = *vector::borrow(&buf, i); + // If it is a valid ascii character, keep it. + if (ascii::is_valid_char(b)) { + vector::push_back(&mut asciified, b); + i = i + 1; + } else { + // Since UTF-8 characters have variable-length encoding (they are + // represented using 1-4 bytes, unlike ASCII characters, which + // are represented using 1 byte), we don't want to transform + // every byte in a UTF-8 string that does not represent an ASCII + // character to the question mark symbol "?". This would result + // in having too many "?" symbols. + // + // Instead, we want a single "?" for each character. Note that + // the 1-byte UTF-8 characters correspond to valid ASCII + // characters and have the form 0xxxxxxx. + // The 2, 3, and 4-byte UTF-8 characters have first byte equal + // to: + // - 110xxxxx // 192 + // - 1110xxxx // 224 + // - or 11110xxx // 240 + // + // and remaining bytes of the form: + // - 10xxxxxx + // + // To ensure a one-to-one mapping of a multi-byte UTF-8 character + // to a "?", we detect the first byte of a new UTF-8 character + // in a multi-byte representation by checking if it is + // >= 11000000 (base 2) or 192 (base 10) and convert it to a "?" + // and skip the remaining bytes in the same representation. + // + // + // Reference: https://en.wikipedia.org/wiki/UTF-8 + if (b >= UTF8_LENGTH_2_FIRST_BYTE_LOWER_BOUND){ + vector::push_back(&mut asciified, QUESTION_MARK); + if (b >= UTF8_LENGTH_4_FIRST_BYTE_LOWER_BOUND){ + // The UTF-8 char has a 4-byte hex representation. + i = i + 4; + } else if (b >= UTF8_LENGTH_3_FIRST_BYTE_LOWER_BOUND){ + // The UTF-8 char has a 3-byte hex representation. + i = i + 3; + } else { + // The UTF-8 char has a 2-byte hex representation. + i = i + 2; + } + } + }; + }; + ascii::string(asciified) + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/vaa.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/vaa.move new file mode 100644 index 0000000000..726ffa449f --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/vaa.move @@ -0,0 +1,351 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module builds on Wormhole's `vaa::parse_and_verify` method by adding +/// emitter verification and replay protection. +/// +/// Token Bridge only cares about other Token Bridge messages, so the emitter +/// address must be a registered Token Bridge emitter according to the VAA's +/// emitter chain ID. +/// +/// Token Bridge does not allow replaying any of its VAAs, so its hash is stored +/// in its `State`. If the encoded VAA passes through `parse_and_verify` again, +/// it will abort. +module token_bridge::vaa { + use iota::table::{Self}; + use wormhole::external_address::{ExternalAddress}; + use wormhole::vaa::{Self, VAA}; + + use token_bridge::state::{Self, State}; + + friend token_bridge::create_wrapped; + friend token_bridge::complete_transfer; + friend token_bridge::complete_transfer_with_payload; + + /// For a given chain ID, Token Bridge is non-existent. + const E_UNREGISTERED_EMITTER: u64 = 0; + /// Encoded emitter address does not match registered Token Bridge. + const E_EMITTER_ADDRESS_MISMATCH: u64 = 1; + + /// This type represents VAA data whose emitter is a registered Token Bridge + /// emitter. This message is also representative of a VAA that cannot be + /// replayed. + struct TokenBridgeMessage { + /// Wormhole chain ID from which network the message originated from. + emitter_chain: u16, + /// Address of Token Bridge (standardized to 32 bytes) that produced + /// this message. + emitter_address: ExternalAddress, + /// Sequence number of Token Bridge's Wormhole message. + sequence: u64, + /// Token Bridge payload. + payload: vector + } + + /// Parses and verifies encoded VAA. Because Token Bridge does not allow + /// VAAs to be replayed, the VAA hash is stored in a set, which is checked + /// against the next time the same VAA is used to make sure it cannot be + /// used again. + /// + /// In its verification, this method checks whether the emitter is a + /// registered Token Bridge contract on another network. + /// + /// NOTE: It is important for integrators to refrain from calling this + /// method within their contracts. This method is meant to be called within + /// a transaction block, passing the `TokenBridgeMessage` to one of the + /// Token Bridge methods that consumes this type. If in a circumstance where + /// this module has a breaking change in an upgrade, another method (e.g. + /// `complete_transfer_with_payload`) will not be affected by this change. + public fun verify_only_once( + token_bridge_state: &mut State, + verified_vaa: VAA + ): TokenBridgeMessage { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // First parse and verify VAA using Wormhole. This also consumes the VAA + // hash to prevent replay. + vaa::consume( + state::borrow_mut_consumed_vaas(&latest_only, token_bridge_state), + &verified_vaa + ); + + // Does the emitter agree with a registered Token Bridge? + assert_registered_emitter(token_bridge_state, &verified_vaa); + + // Take emitter info, sequence and payload. + let sequence = vaa::sequence(&verified_vaa); + let ( + emitter_chain, + emitter_address, + payload + ) = vaa::take_emitter_info_and_payload(verified_vaa); + + TokenBridgeMessage { + emitter_chain, + emitter_address, + sequence, + payload + } + } + + public fun emitter_chain(self: &TokenBridgeMessage): u16 { + self.emitter_chain + } + + public fun emitter_address(self: &TokenBridgeMessage): ExternalAddress { + self.emitter_address + } + + public fun sequence(self: &TokenBridgeMessage): u64 { + self.sequence + } + + /// Destroy `TokenBridgeMessage` and extract payload, which is the same + /// payload in the `VAA`. + /// + /// NOTE: This is a privileged method, which only friends within the Token + /// Bridge package can use. This guarantees that no other package can redeem + /// a VAA intended for Token Bridge as a denial-of-service by calling + /// `verify_only_once` and then destroying it by calling it this method. + public(friend) fun take_payload(msg: TokenBridgeMessage): vector { + let TokenBridgeMessage { + emitter_chain: _, + emitter_address: _, + sequence: _, + payload + } = msg; + + payload + } + + /// Assert that a given emitter equals one that is registered as a foreign + /// Token Bridge. + fun assert_registered_emitter( + token_bridge_state: &State, + verified_vaa: &VAA + ) { + let chain = vaa::emitter_chain(verified_vaa); + let registry = state::borrow_emitter_registry(token_bridge_state); + assert!(table::contains(registry, chain), E_UNREGISTERED_EMITTER); + + let registered = table::borrow(registry, chain); + let emitter_addr = vaa::emitter_address(verified_vaa); + assert!(*registered == emitter_addr, E_EMITTER_ADDRESS_MISMATCH); + } + + #[test_only] + public fun destroy(msg: TokenBridgeMessage) { + take_payload(msg); + } +} + +#[test_only] +module token_bridge::vaa_tests { + use iota::test_scenario::{Self}; + use wormhole::external_address::{Self}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + person, + register_dummy_emitter, + return_state, + set_up_wormhole_and_token_bridge, + take_state + }; + use token_bridge::vaa::{Self}; + + /// VAA sent from the ethereum token bridge 0xdeadbeef. + const VAA: vector = + x"01000000000100102d399190fa61daccb11c2ea4f7a3db3a9365e5936bcda4cded87c1b9eeb095173514f226256d5579af71d4089eb89496befb998075ba94cd1d4460c5c57b84000000000100000001000200000000000000000000000000000000000000000000000000000000deadbeef0000000002634973000200000000000000000000000000000000000000000000000000000000beefface00020c0000000000000000000000000000000000000000000000000000000042454546000000000000000000000000000000000042656566206661636520546f6b656e"; + + #[test] + #[expected_failure(abort_code = vaa::E_UNREGISTERED_EMITTER)] + fun test_cannot_verify_only_once_unregistered_chain() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + // You shall not pass! + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Clean up. + vaa::destroy(msg); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = vaa::E_EMITTER_ADDRESS_MISMATCH)] + fun test_cannot_verify_only_once_emitter_address_mismatch() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + // First register emitter. + let emitter_chain = 2; + let emitter_addr = external_address::from_address(@0xdeafbeef); + token_bridge::register_chain::register_new_emitter_test_only( + &mut token_bridge_state, + emitter_chain, + emitter_addr + ); + + // Confirm that encoded emitter disagrees with registered emitter. + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + assert!( + wormhole::vaa::emitter_address(&verified_vaa) != emitter_addr, + 0 + ); + + // You shall not pass! + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Clean up. + vaa::destroy(msg); + + abort 42 + } + + #[test] + fun test_verify_only_once() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + // Confirm VAA originated from where we expect. + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + assert!( + wormhole::vaa::emitter_chain(&verified_vaa) == expected_source_chain, + 0 + ); + + // Finally verify. + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Clean up. + vaa::destroy(msg); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::set::E_KEY_ALREADY_EXISTS)] + fun test_cannot_verify_only_once_again() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + // Confirm VAA originated from where we expect. + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + assert!( + wormhole::vaa::emitter_chain(&verified_vaa) == expected_source_chain, + 0 + ); + + // Finally verify. + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + vaa::destroy(msg); + + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + // You shall not pass! + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Clean up. + vaa::destroy(msg); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_verify_only_once_outdated_version() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + // Verify VAA. + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Clean up. + vaa::destroy(msg); + + abort 42 + } + +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/version_control.move b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/version_control.move new file mode 100644 index 0000000000..d36f8f2fdc --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/token_bridge/sources/version_control.move @@ -0,0 +1,72 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements dynamic field keys as empty structs. These keys are +/// used to determine the latest version for this build. If the current version +/// is not this build's, then paths through the `state` module will abort. +/// +/// See `token_bridge::state` and `wormhole::package_utils` for more info. +module token_bridge::version_control { + //////////////////////////////////////////////////////////////////////////// + // + // Hard-coded Version Control + // + // Before upgrading, please set the types for `current_version` and + // `previous_version` to match the correct types (current being the latest + // version reflecting this build). + // + //////////////////////////////////////////////////////////////////////////// + + public(friend) fun current_version(): V__0_2_0 { + V__0_2_0 {} + } + + #[test_only] + public fun current_version_test_only(): V__0_2_0 { + current_version() + } + + public(friend) fun previous_version(): V__DUMMY { + V__DUMMY {} + } + + #[test_only] + public fun previous_version_test_only(): V__DUMMY { + previous_version() + } + + //////////////////////////////////////////////////////////////////////////// + // + // Change Log + // + // Please write release notes as doc strings for each version struct. These + // notes will be our attempt at tracking upgrades. Wish us luck. + // + //////////////////////////////////////////////////////////////////////////// + + /// First published package on Iota mainnet. + struct V__0_2_0 has store, drop, copy {} + + // Dummy. + struct V__DUMMY has store, drop, copy {} + + //////////////////////////////////////////////////////////////////////////// + // + // Implementation and Test-Only Methods + // + //////////////////////////////////////////////////////////////////////////// + + friend token_bridge::state; + + #[test_only] + public fun dummy(): V__DUMMY { + V__DUMMY {} + } + + #[test_only] + struct V__MIGRATED has store, drop, copy {} + + #[test_only] + public fun next_version(): V__MIGRATED { + V__MIGRATED {} + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/.gitignore b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/.gitignore new file mode 100644 index 0000000000..378eac25d3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/.gitignore @@ -0,0 +1 @@ +build diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Makefile b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Makefile new file mode 100644 index 0000000000..1f9d45f8af --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Makefile @@ -0,0 +1,18 @@ +-include ../../Makefile.help + +VERSION = $(shell grep -Po "version = \"\K[^\"]*" Move.toml | sed "s/\./_/g") + +.PHONY: clean +clean: + rm -rf build + +.PHONY: check +## Build contract +check: + sui move build -d + +.PHONY: test +## Run tests +test: check + grep "public(friend) fun current_version(): V__${VERSION} {" sources/version_control.move + sui move test -d -t 1 diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.devnet.toml b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.devnet.toml new file mode 100644 index 0000000000..ba3f5e54aa --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.devnet.toml @@ -0,0 +1,11 @@ +[package] +name = "Wormhole" +version = "0.2.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[addresses] +wormhole = "_" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.lock b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.lock new file mode 100644 index 0000000000..540307f10f --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.lock @@ -0,0 +1,35 @@ +# @generated by Move, please check-in and do not edit manually. + +[move] +version = 0 +manifest_digest = "6E83C6D69B7F45D2ACF973DFF878405621DC0E67C0EE2D4A28748A7FDD907AA1" +deps_digest = "F8BBB0CCB2491CA29A3DF03D6F92277A4F3574266507ACD77214D37ECA3F3082" + +dependencies = [ + { name = "Iota" }, +] + +[[move.package]] +name = "Iota" +source = { git = "https://github.com/iotaledger/iota.git", rev = "751c23caf24efd071463b9ffd07eabcb15f44f31", subdir = "crates/iota-framework/packages/iota-framework" } + +dependencies = [ + { name = "MoveStdlib" }, +] + +[[move.package]] +name = "MoveStdlib" +source = { git = "https://github.com/iotaledger/iota.git", rev = "751c23caf24efd071463b9ffd07eabcb15f44f31", subdir = "crates/iota-framework/packages/move-stdlib" } + +[move.toolchain-version] +compiler-version = "0.9.2-rc" +edition = "2024.beta" +flavor = "iota" + +[env] + +[env.testnet] +chain-id = "2304aa97" +original-published-id = "0xfca58c557f09cddb7930588c4e2a4edbe3cdded1ac1ed2270aa2dfa8d2b9ae0d" +latest-published-id = "0xfca58c557f09cddb7930588c4e2a4edbe3cdded1ac1ed2270aa2dfa8d2b9ae0d" +published-version = "1" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.mainnet.toml b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.mainnet.toml new file mode 100644 index 0000000000..7465390ebb --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.mainnet.toml @@ -0,0 +1,12 @@ +[package] +name = "Wormhole" +version = "0.2.0" +published-at = "0x5306f64e312b581766351c07af79c72fcb1cd25147157fdc2f8ad76de9a3fb6a" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[addresses] +wormhole = "0x5306f64e312b581766351c07af79c72fcb1cd25147157fdc2f8ad76de9a3fb6a" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.testnet.toml b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.testnet.toml new file mode 100644 index 0000000000..ed34ccb472 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.testnet.toml @@ -0,0 +1,12 @@ +[package] +name = "Wormhole" +version = "0.2.0" +published-at = "0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[addresses] +wormhole = "0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.toml b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.toml new file mode 100644 index 0000000000..e0197a6e62 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/Move.toml @@ -0,0 +1,12 @@ +[package] +name = "Wormhole" +version = "0.2.0" +published-at = "0xfca58c557f09cddb7930588c4e2a4edbe3cdded1ac1ed2270aa2dfa8d2b9ae0d" + +[dependencies.Iota] +git = "https://github.com/iotaledger/iota.git" +subdir = "crates/iota-framework/packages/iota-framework" +rev = "751c23caf24efd071463b9ffd07eabcb15f44f31" + +[addresses] +wormhole = "0xfca58c557f09cddb7930588c4e2a4edbe3cdded1ac1ed2270aa2dfa8d2b9ae0d" diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/README.md b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/README.md new file mode 100644 index 0000000000..62a62a67b1 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/README.md @@ -0,0 +1,25 @@ +# Sui Wormhole Core Bridge Design + +## State + +The `State` object is created exactly once during the initialisation of the +contract. Normally, run-once functionality is implemented in the special `init` +function of a module (this code runs once, when the module is first deployed), +but this function takes no arguments, while our initialisation code does (to +ease deployment to different environments without recompiling the contract). + +To allow configuring the state with arguments, it's initialised in the +`init_and_share_state` function, which also shares the state object. To ensure +this function can only be called once, it consumes a `DeployerCap` object +which in turn is created and transferred to the deployer in the `init` function. +Since `init_and_share_state` consumes this object, it won't be possible to call +it again. + +## Dynamic fields + +TODO: up to date notes on where and how we use dynamic fields. + +## Epoch Timestamp + +Sui currently does not have fine-grained timestamps, so we use +`tx_context::epoch(ctx)` in place of on-chain time in seconds. diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/datatypes/bytes20.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/datatypes/bytes20.move new file mode 100644 index 0000000000..3c097dec69 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/datatypes/bytes20.move @@ -0,0 +1,176 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type representing a fixed-size array of +/// length 20. +module wormhole::bytes20 { + use std::vector::{Self}; + + use wormhole::bytes::{Self}; + use wormhole::cursor::{Cursor}; + + /// Invalid vector length to create `Bytes20`. + const E_INVALID_BYTES20: u64 = 0; + /// Found non-zero bytes when attempting to trim `vector`. + const E_CANNOT_TRIM_NONZERO: u64 = 1; + + /// 20. + const LEN: u64 = 20; + + /// Container for `vector`, which has length == 20. + struct Bytes20 has copy, drop, store { + data: vector + } + + public fun length(): u64 { + LEN + } + + /// Create new `Bytes20`, which checks the length of input `data`. + public fun new(data: vector): Bytes20 { + assert!(is_valid(&data), E_INVALID_BYTES20); + Bytes20 { data } + } + + /// Create new `Bytes20` of all zeros. + public fun default(): Bytes20 { + let data = vector::empty(); + let i = 0; + while (i < LEN) { + vector::push_back(&mut data, 0); + i = i + 1; + }; + new(data) + } + + /// Retrieve underlying `data`. + public fun data(self: &Bytes20): vector { + self.data + } + + /// Either trim or pad (depending on length of the input `vector`) to 20 + /// bytes. + public fun from_bytes(buf: vector): Bytes20 { + let len = vector::length(&buf); + if (len > LEN) { + trim_nonzero_left(&mut buf); + new(buf) + } else { + new(pad_left(&buf, false)) + } + } + + /// Destroy `Bytes20` for its underlying data. + public fun to_bytes(value: Bytes20): vector { + let Bytes20 { data } = value; + data + } + + /// Drain 20 elements of `Cursor` to create `Bytes20`. + public fun take(cur: &mut Cursor): Bytes20 { + new(bytes::take_bytes(cur, LEN)) + } + + /// Validate that any of the bytes in underlying data is non-zero. + public fun is_nonzero(self: &Bytes20): bool { + let i = 0; + while (i < LEN) { + if (*vector::borrow(&self.data, i) > 0) { + return true + }; + i = i + 1; + }; + + false + } + + /// Check that the input data is correct length. + fun is_valid(data: &vector): bool { + vector::length(data) == LEN + } + + /// For vector size less than 20, add zeros to the left. + fun pad_left(data: &vector, data_reversed: bool): vector { + let out = vector::empty(); + let len = vector::length(data); + let i = len; + while (i < LEN) { + vector::push_back(&mut out, 0); + i = i + 1; + }; + if (data_reversed) { + let i = 0; + while (i < len) { + vector::push_back( + &mut out, + *vector::borrow(data, len - i - 1) + ); + i = i + 1; + }; + } else { + vector::append(&mut out, *data); + }; + + out + } + + /// Trim bytes from the left if they are zero. If any of these bytes + /// are non-zero, abort. + fun trim_nonzero_left(data: &mut vector) { + vector::reverse(data); + let (i, n) = (0, vector::length(data) - LEN); + while (i < n) { + assert!(vector::pop_back(data) == 0, E_CANNOT_TRIM_NONZERO); + i = i + 1; + }; + vector::reverse(data); + } +} + +#[test_only] +module wormhole::bytes20_tests { + use std::vector::{Self}; + + use wormhole::bytes20::{Self}; + + #[test] + public fun new() { + let data = x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + assert!(vector::length(&data) == 20, 0); + let actual = bytes20::new(data); + + assert!(bytes20::data(&actual) == data, 0); + } + + #[test] + public fun default() { + let actual = bytes20::default(); + let expected = x"0000000000000000000000000000000000000000"; + assert!(bytes20::data(&actual) == expected, 0); + } + + #[test] + public fun from_bytes() { + let actual = bytes20::from_bytes(x"deadbeef"); + let expected = x"00000000000000000000000000000000deadbeef"; + assert!(bytes20::data(&actual) == expected, 0); + } + + #[test] + public fun is_nonzero() { + let data = x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + let actual = bytes20::new(data); + assert!(bytes20::is_nonzero(&actual), 0); + + let zeros = bytes20::default(); + assert!(!bytes20::is_nonzero(&zeros), 0); + } + + #[test] + #[expected_failure(abort_code = bytes20::E_INVALID_BYTES20)] + public fun cannot_new_non_20_byte_vector() { + let data = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbe"; + assert!(vector::length(&data) != 20, 0); + bytes20::new(data); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/datatypes/bytes32.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/datatypes/bytes32.move new file mode 100644 index 0000000000..5c0157b9e7 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/datatypes/bytes32.move @@ -0,0 +1,287 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type representing a fixed-size array of +/// length 32. +module wormhole::bytes32 { + use std::option::{Self}; + use std::string::{Self, String}; + use std::vector::{Self}; + use iota::bcs::{Self}; + + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self, Cursor}; + + /// Invalid vector length to create `Bytes32`. + const E_INVALID_BYTES32: u64 = 0; + /// Found non-zero bytes when attempting to trim `vector`. + const E_CANNOT_TRIM_NONZERO: u64 = 1; + /// Value of deserialized 32-byte array data overflows u64 max. + const E_U64_OVERFLOW: u64 = 2; + + /// 32. + const LEN: u64 = 32; + + /// Container for `vector`, which has length == 32. + struct Bytes32 has copy, drop, store { + data: vector, + } + + public fun length(): u64 { + LEN + } + + /// Create new `Bytes32`, which checks the length of input `data`. + public fun new(data: vector): Bytes32 { + assert!(is_valid(&data), E_INVALID_BYTES32); + Bytes32 { data } + } + + /// Create new `Bytes20` of all zeros. + public fun default(): Bytes32 { + let data = vector::empty(); + let i = 0; + while (i < LEN) { + vector::push_back(&mut data, 0); + i = i + 1; + }; + new(data) + } + + /// Retrieve underlying `data`. + public fun data(self: &Bytes32): vector { + self.data + } + + /// Serialize `u256` as big-endian format in zero-padded `Bytes32`. + public fun from_u256_be(value: u256): Bytes32 { + let buf = bcs::to_bytes(&value); + vector::reverse(&mut buf); + new(buf) + } + + /// Deserialize from big-endian `u256`. + public fun to_u256_be(value: Bytes32): u256 { + let cur = cursor::new(to_bytes(value)); + let out = bytes::take_u256_be(&mut cur); + cursor::destroy_empty(cur); + + out + } + + /// Serialize `u64` as big-endian format in zero-padded `Bytes32`. + public fun from_u64_be(value: u64): Bytes32 { + from_u256_be((value as u256)) + } + + /// Deserialize from big-endian `u64` as long as the data does not + /// overflow. + public fun to_u64_be(value: Bytes32): u64 { + let num = to_u256_be(value); + assert!(num < (1u256 << 64), E_U64_OVERFLOW); + (num as u64) + } + + /// Either trim or pad (depending on length of the input `vector`) to 32 + /// bytes. + public fun from_bytes(buf: vector): Bytes32 { + let len = vector::length(&buf); + if (len > LEN) { + trim_nonzero_left(&mut buf); + new(buf) + } else { + new(pad_left(&buf, false)) + } + } + + /// Destroy `Bytes32` for its underlying data. + public fun to_bytes(value: Bytes32): vector { + let Bytes32 { data } = value; + data + } + + /// Drain 32 elements of `Cursor` to create `Bytes32`. + public fun take_bytes(cur: &mut Cursor): Bytes32 { + new(bytes::take_bytes(cur, LEN)) + } + + /// Destroy `Bytes32` to represent its underlying data as `address`. + public fun to_address(value: Bytes32): address { + iota::address::from_bytes(to_bytes(value)) + } + + /// Create `Bytes32` from `address`. + public fun from_address(addr: address): Bytes32 { + new(iota::address::to_bytes(addr)) + } + + public fun from_utf8(str: String): Bytes32 { + let data = *string::bytes(&str); + let len = vector::length(&data); + if (len > LEN) { + // Trim from end. + let i = len; + while (i > LEN) { + vector::pop_back(&mut data); + i = i - 1; + } + } else { + // Pad right to `LEN`. + let i = len; + while (i < LEN) { + vector::push_back(&mut data, 0); + i = i + 1; + } + }; + + new(data) + } + + /// Even if the input is valid utf8, the result might be shorter than 32 + /// bytes, because the original string might have a multi-byte utf8 + /// character at the 32 byte boundary, which, when split, results in an + /// invalid code point, so we remove it. + public fun to_utf8(value: Bytes32): String { + let data = to_bytes(value); + + let utf8 = string::try_utf8(data); + while (option::is_none(&utf8)) { + vector::pop_back(&mut data); + utf8 = string::try_utf8(data); + }; + + let buf = *string::bytes(&option::extract(&mut utf8)); + + // Now trim zeros from the right. + while ( + *vector::borrow(&buf, vector::length(&buf) - 1) == 0 + ) { + vector::pop_back(&mut buf); + }; + + string::utf8(buf) + } + + /// Validate that any of the bytes in underlying data is non-zero. + public fun is_nonzero(self: &Bytes32): bool { + let i = 0; + while (i < LEN) { + if (*vector::borrow(&self.data, i) > 0) { + return true + }; + i = i + 1; + }; + + false + } + + /// Check that the input data is correct length. + fun is_valid(data: &vector): bool { + vector::length(data) == LEN + } + + /// For vector size less than 32, add zeros to the left. + fun pad_left(data: &vector, data_reversed: bool): vector { + let out = vector::empty(); + let len = vector::length(data); + let i = len; + while (i < LEN) { + vector::push_back(&mut out, 0); + i = i + 1; + }; + if (data_reversed) { + let i = 0; + while (i < len) { + vector::push_back( + &mut out, + *vector::borrow(data, len - i - 1) + ); + i = i + 1; + }; + } else { + vector::append(&mut out, *data); + }; + + out + } + + /// Trim bytes from the left if they are zero. If any of these bytes + /// are non-zero, abort. + fun trim_nonzero_left(data: &mut vector) { + vector::reverse(data); + let (i, n) = (0, vector::length(data) - LEN); + while (i < n) { + assert!(vector::pop_back(data) == 0, E_CANNOT_TRIM_NONZERO); + i = i + 1; + }; + vector::reverse(data); + } +} + +#[test_only] +module wormhole::bytes32_tests { + use std::vector::{Self}; + + use wormhole::bytes32::{Self}; + + #[test] + public fun new() { + let data = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + assert!(vector::length(&data) == 32, 0); + let actual = bytes32::new(data); + + assert!(bytes32::data(&actual) == data, 0); + } + + #[test] + public fun default() { + let actual = bytes32::default(); + let expected = + x"0000000000000000000000000000000000000000000000000000000000000000"; + assert!(bytes32::data(&actual) == expected, 0); + } + + #[test] + public fun from_u256_be() { + let actual = bytes32::from_u256_be(1 << 32); + let expected = + x"0000000000000000000000000000000000000000000000000000000100000000"; + assert!(bytes32::data(&actual) == expected, 0); + } + + #[test] + public fun to_u256_be() { + let actual = bytes32::new( + x"0000000000000000000000000000000000000000000000000000000100000000" + ); + assert!(bytes32::to_u256_be(actual) == (1 << 32), 0); + } + + #[test] + public fun from_bytes() { + let actual = bytes32::from_bytes(x"deadbeef"); + let expected = + x"00000000000000000000000000000000000000000000000000000000deadbeef"; + assert!(bytes32::data(&actual) == expected, 0); + } + + #[test] + public fun is_nonzero() { + let data = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + let actual = bytes32::new(data); + assert!(bytes32::is_nonzero(&actual), 0); + + let zeros = bytes32::default(); + assert!(!bytes32::is_nonzero(&zeros), 0); + } + + #[test] + #[expected_failure(abort_code = bytes32::E_INVALID_BYTES32)] + public fun cannot_new_non_32_byte_vector() { + let data = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbe"; + assert!(vector::length(&data) != 32, 0); + bytes32::new(data); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/datatypes/external_address.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/datatypes/external_address.move new file mode 100644 index 0000000000..7bf326c738 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/datatypes/external_address.move @@ -0,0 +1,102 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type for a 32-byte standardized address, +/// which is meant to represent an address from any other network. +module wormhole::external_address { + use iota::object::{Self, ID}; + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::cursor::{Cursor}; + + /// Underlying data is all zeros. + const E_ZERO_ADDRESS: u64 = 0; + + /// Container for `Bytes32`. + struct ExternalAddress has copy, drop, store { + value: Bytes32, + } + + /// Create `ExternalAddress`. + public fun new(value: Bytes32): ExternalAddress { + ExternalAddress { value } + } + + /// Create `ExternalAddress` of all zeros.` + public fun default(): ExternalAddress { + new(bytes32::default()) + } + + /// Create `ExternalAddress` ensuring that not all bytes are zero. + public fun new_nonzero(value: Bytes32): ExternalAddress { + assert!(bytes32::is_nonzero(&value), E_ZERO_ADDRESS); + new(value) + } + + /// Destroy `ExternalAddress` for underlying bytes as `vector`. + public fun to_bytes(ext: ExternalAddress): vector { + bytes32::to_bytes(to_bytes32(ext)) + } + + /// Destroy 'ExternalAddress` for underlying data. + public fun to_bytes32(ext: ExternalAddress): Bytes32 { + let ExternalAddress { value } = ext; + value + } + + /// Drain 32 elements of `Cursor` to create `ExternalAddress`. + public fun take_bytes(cur: &mut Cursor): ExternalAddress { + new(bytes32::take_bytes(cur)) + } + + /// Drain 32 elements of `Cursor` to create `ExternalAddress` ensuring + /// that not all bytes are zero. + public fun take_nonzero(cur: &mut Cursor): ExternalAddress { + new_nonzero(bytes32::take_bytes(cur)) + } + + /// Destroy `ExternalAddress` to represent its underlying data as `address`. + public fun to_address(ext: ExternalAddress): address { + iota::address::from_bytes(to_bytes(ext)) + } + + /// Create `ExternalAddress` from `address`. + public fun from_address(addr: address): ExternalAddress { + new(bytes32::from_address(addr)) + } + + /// Create `ExternalAddress` from `ID`. + public fun from_id(id: ID): ExternalAddress { + new(bytes32::from_bytes(object::id_to_bytes(&id))) + } + + /// Check whether underlying data is not all zeros. + public fun is_nonzero(self: &ExternalAddress): bool { + bytes32::is_nonzero(&self.value) + } +} + +#[test_only] +module wormhole::external_address_tests { + use wormhole::bytes32::{Self}; + use wormhole::external_address::{Self}; + + #[test] + public fun test_bytes() { + let data = + bytes32::new( + x"1234567891234567891234567891234512345678912345678912345678912345" + ); + let addr = external_address::new(data); + assert!(external_address::to_bytes(addr) == bytes32::to_bytes(data), 0); + } + + #[test] + public fun test_address() { + let data = + bytes32::new( + x"0000000000000000000000000000000000000000000000000000000000001234" + ); + let addr = external_address::new(data); + assert!(external_address::to_address(addr) == @0x1234, 0); + assert!(addr == external_address::from_address(@0x1234), 0); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/datatypes/guardian_signature.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/datatypes/guardian_signature.move new file mode 100644 index 0000000000..58698d51a6 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/datatypes/guardian_signature.move @@ -0,0 +1,64 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type representing a Guardian's signature +/// with recovery ID of a particular hashed VAA message body. The components of +/// `GuardianSignature` are used to perform public key recovery using ECDSA. +module wormhole::guardian_signature { + use std::vector::{Self}; + + use wormhole::bytes32::{Self, Bytes32}; + + /// Container for elliptic curve signature parameters and Guardian index. + struct GuardianSignature has store, drop { + r: Bytes32, + s: Bytes32, + recovery_id: u8, + index: u8, + } + + /// Create new `GuardianSignature`. + public fun new( + r: Bytes32, + s: Bytes32, + recovery_id: u8, + index: u8 + ): GuardianSignature { + GuardianSignature { r, s, recovery_id, index } + } + + /// 32-byte signature parameter R. + public fun r(self: &GuardianSignature): Bytes32 { + self.r + } + + /// 32-byte signature parameter S. + public fun s(self: &GuardianSignature): Bytes32 { + self.s + } + + /// Signature recovery ID. + public fun recovery_id(self: &GuardianSignature): u8 { + self.recovery_id + } + + /// Guardian index. + public fun index(self: &GuardianSignature): u8 { + self.index + } + + /// Guardian index as u64. + public fun index_as_u64(self: &GuardianSignature): u64 { + (self.index as u64) + } + + /// Serialize elliptic curve paramters as `vector` of length == 65 to be + /// consumed by `ecdsa_k1` for public key recovery. + public fun to_rsv(gs: GuardianSignature): vector { + let GuardianSignature { r, s, recovery_id, index: _ } = gs; + let out = vector::empty(); + vector::append(&mut out, bytes32::to_bytes(r)); + vector::append(&mut out, bytes32::to_bytes(s)); + vector::push_back(&mut out, recovery_id); + out + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/emitter.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/emitter.move new file mode 100644 index 0000000000..109f35f0e5 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/emitter.move @@ -0,0 +1,183 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a capability (`EmitterCap`), which allows one to send +/// Wormhole messages. Its external address is determined by the capability's +/// `id`, which is a 32-byte vector. +module wormhole::emitter { + use iota::object::{Self, ID, UID}; + use iota::tx_context::{TxContext}; + + use wormhole::state::{Self, State}; + + friend wormhole::publish_message; + + /// Event reflecting when `new` is called. + struct EmitterCreated has drop, copy { + emitter_cap: ID + } + + /// Event reflecting when `destroy` is called. + struct EmitterDestroyed has drop, copy { + emitter_cap: ID + } + + /// `EmitterCap` is a Iota object that gives a user or smart contract the + /// capability to send Wormhole messages. For every Wormhole message + /// emitted, a unique `sequence` is used. + struct EmitterCap has key, store { + id: UID, + + /// Sequence number of the next wormhole message. + sequence: u64 + } + + /// Generate a new `EmitterCap`. + public fun new(wormhole_state: &State, ctx: &mut TxContext): EmitterCap { + state::assert_latest_only(wormhole_state); + + let cap = + EmitterCap { + id: object::new(ctx), + sequence: 0 + }; + + iota::event::emit( + EmitterCreated { emitter_cap: object::id(&cap)} + ); + + cap + } + + /// Returns current sequence (which will be used in the next Wormhole + /// message emitted). + public fun sequence(self: &EmitterCap): u64 { + self.sequence + } + + /// Once a Wormhole message is emitted, an `EmitterCap` upticks its + /// internal `sequence` for the next message. + public(friend) fun use_sequence(self: &mut EmitterCap): u64 { + let sequence = self.sequence; + self.sequence = sequence + 1; + sequence + } + + /// Destroys an `EmitterCap`. + /// + /// Note that this operation removes the ability to send messages using the + /// emitter id, and is irreversible. + public fun destroy(wormhole_state: &State, cap: EmitterCap) { + state::assert_latest_only(wormhole_state); + + iota::event::emit( + EmitterDestroyed { emitter_cap: object::id(&cap) } + ); + + let EmitterCap { id, sequence: _ } = cap; + object::delete(id); + } + + #[test_only] + public fun destroy_test_only(cap: EmitterCap) { + let EmitterCap { id, sequence: _ } = cap; + object::delete(id); + } + + #[test_only] + public fun dummy(): EmitterCap { + EmitterCap { + id: object::new(&mut iota::tx_context::dummy()), + sequence: 0 + } + } +} + +#[test_only] +module wormhole::emitter_tests { + use iota::object::{Self}; + use iota::test_scenario::{Self}; + + use wormhole::emitter::{Self}; + use wormhole::state::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + person, + return_state, + set_up_wormhole, + take_state + }; + + #[test] + fun test_emitter() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + + let dummy_cap = emitter::dummy(); + let expected = + @0x381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f409; + assert!(object::id_to_address(&object::id(&dummy_cap)) == expected, 0); + + // Generate new emitter. + let cap = emitter::new(&worm_state, test_scenario::ctx(scenario)); + + // And check emitter cap's address. + let expected = + @0x75c3360eb19fd2c20fbba5e2da8cf1a39cdb1ee913af3802ba330b852e459e05; + assert!(object::id_to_address(&object::id(&cap)) == expected, 0); + + // Clean up. + emitter::destroy(&worm_state, dummy_cap); + emitter::destroy(&worm_state, cap); + return_state(worm_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_new_emitter_outdated_version() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + // You shall not pass! + let cap = emitter::new(&worm_state, test_scenario::ctx(scenario)); + + // Clean up. + emitter::destroy(&worm_state, cap); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance/set_fee.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance/set_fee.move new file mode 100644 index 0000000000..68a7c8bfe1 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance/set_fee.move @@ -0,0 +1,343 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact setting the +/// Wormhole message fee to another amount. +module wormhole::set_fee { + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Self}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + use wormhole::state::{Self, State}; + + /// Specific governance payload ID (action) for setting Wormhole fee. + const ACTION_SET_FEE: u8 = 3; + + struct GovernanceWitness has drop {} + + struct SetFee { + amount: u64 + } + + public fun authorize_governance( + wormhole_state: &State + ): DecreeTicket { + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(wormhole_state), + state::governance_contract(wormhole_state), + state::governance_module(), + ACTION_SET_FEE + ) + } + + /// Redeem governance VAA to configure Wormhole message fee amount in IOTA + /// denomination. This governance message is only relevant for Iota because + /// fee administration is only relevant to one particular network (in this + /// case Iota). + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + public fun set_fee( + wormhole_state: &mut State, + receipt: DecreeReceipt + ): u64 { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(wormhole_state); + + let payload = + governance_message::take_payload( + state::borrow_mut_consumed_vaas(&latest_only, wormhole_state), + receipt + ); + + // Deserialize the payload as amount to change the Wormhole fee. + let SetFee { amount } = deserialize(payload); + + state::set_message_fee(&latest_only, wormhole_state, amount); + + amount + } + + fun deserialize(payload: vector): SetFee { + let cur = cursor::new(payload); + + // This amount cannot be greater than max u64. + let amount = bytes32::to_u64_be(bytes32::take_bytes(&mut cur)); + + cursor::destroy_empty(cur); + + SetFee { amount: (amount as u64) } + } + + #[test_only] + public fun action(): u8 { + ACTION_SET_FEE + } +} + +#[test_only] +module wormhole::set_fee_tests { + use iota::balance::{Self}; + use iota::test_scenario::{Self}; + + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::governance_message::{Self}; + use wormhole::set_fee::{Self}; + use wormhole::state::{Self}; + use wormhole::vaa::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + person, + return_clock, + return_state, + set_up_wormhole, + take_clock, + take_state, + upgrade_wormhole + }; + + const VAA_SET_FEE_1: vector = + x"01000000000100181aa27fd44f3060fad0ae72895d42f97c45f7a5d34aa294102911370695e91e17ae82caa59f779edde2356d95cd46c2c381cdeba7a8165901a562374f212d750000bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f7265030015000000000000000000000000000000000000000000000000000000000000015e"; + const VAA_SET_FEE_MAX: vector = + x"01000000000100b0697fd31572e11b2256cf46d5934f38fbb90e6265e999bee50950846bf9f94d5b86f247cce20e3cc158163be7b5ae21ebaaf67e20d597229ca04d505fd4bc1c0000bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f7265030015000000000000000000000000000000000000000000000000ffffffffffffffff"; + const VAA_SET_FEE_OVERFLOW: vector = + x"01000000000100950a509a797c9b40a678a5d6297f5b74e1ce1794b3c012dad5774c395e65e8b0773cf160113f571f1452ee98d10aa61273b6bc8aefa74a3c8f7e2c9c89fb25fa0000bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f72650300150000000000000000000000000000000000000000000000010000000000000000"; + + #[test] + fun test_set_fee() { + // Testing this method. + use wormhole::set_fee::{set_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 420; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Double-check current fee (from setup). + assert!(state::message_fee(&worm_state) == wormhole_fee, 0); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let fee_amount = set_fee(&mut worm_state, receipt); + assert!(wormhole_fee != fee_amount, 0); + + // Confirm the fee changed. + assert!(state::message_fee(&worm_state) == fee_amount, 0); + + // And confirm that we can deposit the new fee amount. + state::deposit_fee_test_only( + &mut worm_state, + balance::create_for_testing(fee_amount) + ); + + // Finally set the fee again to max u64 (this will effectively pause + // Wormhole message publishing until the fee gets adjusted back to a + // reasonable level again). + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_MAX, &the_clock); + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let fee_amount = set_fee(&mut worm_state, receipt); + + // Confirm. + assert!(state::message_fee(&worm_state) == fee_amount, 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_set_fee_after_upgrade() { + // Testing this method. + use wormhole::set_fee::{set_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 420; + set_up_wormhole(scenario, wormhole_fee); + + // Upgrade. + upgrade_wormhole(scenario); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Double-check current fee (from setup). + assert!(state::message_fee(&worm_state) == wormhole_fee, 0); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let fee_amount = set_fee(&mut worm_state, receipt); + + // Confirm the fee changed. + assert!(state::message_fee(&worm_state) == fee_amount, 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::set::E_KEY_ALREADY_EXISTS)] + fun test_cannot_set_fee_with_same_vaa() { + // Testing this method. + use wormhole::set_fee::{set_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 420; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Set once. + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + set_fee(&mut worm_state, receipt); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // You shall not pass! + set_fee(&mut worm_state, receipt); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::bytes32::E_U64_OVERFLOW)] + fun test_cannot_set_fee_with_overflow() { + // Testing this method. + use wormhole::set_fee::{set_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 420; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Show that the encoded fee is greater than u64 max. + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_SET_FEE_OVERFLOW, + &the_clock + ); + let payload = + governance_message::take_decree(vaa::payload(&verified_vaa)); + let cur = cursor::new(payload); + + let fee_amount = bytes::take_u256_be(&mut cur); + assert!(fee_amount > 0xffffffffffffffff, 0); + + cursor::destroy_empty(cur); + + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // You shall not pass! + set_fee(&mut worm_state, receipt); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_set_fee_outdated_version() { + // Testing this method. + use wormhole::set_fee::{set_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 420; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_SET_FEE_1, + &the_clock + ); + + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // You shall not pass! + set_fee(&mut worm_state, receipt); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance/transfer_fee.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance/transfer_fee.move new file mode 100644 index 0000000000..6ac812ee4e --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance/transfer_fee.move @@ -0,0 +1,529 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact transferring some +/// amount of collected fees to an intended recipient. +module wormhole::transfer_fee { + use iota::coin::{Self}; + use iota::transfer::{Self}; + use iota::tx_context::{TxContext}; + + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + use wormhole::state::{Self, State, LatestOnly}; + + /// Specific governance payload ID (action) for setting Wormhole fee. + const ACTION_TRANSFER_FEE: u8 = 4; + + struct GovernanceWitness has drop {} + + struct TransferFee { + amount: u64, + recipient: address + } + + public fun authorize_governance( + wormhole_state: &State + ): DecreeTicket { + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(wormhole_state), + state::governance_contract(wormhole_state), + state::governance_module(), + ACTION_TRANSFER_FEE + ) + } + + /// Redeem governance VAA to transfer collected Wormhole fees to the + /// recipient encoded in its Wormhole governance message. This governance + /// message is only relevant for Iota because fee administration is only + /// relevant to one particular network (in this case Iota). + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + public fun transfer_fee( + wormhole_state: &mut State, + receipt: DecreeReceipt, + ctx: &mut TxContext + ): u64 { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(wormhole_state); + + let payload = + governance_message::take_payload( + state::borrow_mut_consumed_vaas(&latest_only, wormhole_state), + receipt + ); + + // Proceed with setting the new message fee. + handle_transfer_fee(&latest_only, wormhole_state, payload, ctx) + } + + fun handle_transfer_fee( + latest_only: &LatestOnly, + wormhole_state: &mut State, + governance_payload: vector, + ctx: &mut TxContext + ): u64 { + // Deserialize the payload as amount to withdraw and to whom IOTA should + // be sent. + let TransferFee { amount, recipient } = deserialize(governance_payload); + + transfer::public_transfer( + coin::from_balance( + state::withdraw_fee(latest_only, wormhole_state, amount), + ctx + ), + recipient + ); + + amount + } + + fun deserialize(payload: vector): TransferFee { + let cur = cursor::new(payload); + + // This amount cannot be greater than max u64. + let amount = bytes32::to_u64_be(bytes32::take_bytes(&mut cur)); + + // Recipient must be non-zero address. + let recipient = external_address::take_nonzero(&mut cur); + + cursor::destroy_empty(cur); + + TransferFee { + amount: (amount as u64), + recipient: external_address::to_address(recipient) + } + } + + #[test_only] + public fun action(): u8 { + ACTION_TRANSFER_FEE + } +} + +#[test_only] +module wormhole::transfer_fee_tests { + use iota::balance::{Self}; + use iota::coin::{Self, Coin}; + use iota::iota::{IOTA}; + use iota::test_scenario::{Self}; + + use wormhole::bytes::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self}; + use wormhole::governance_message::{Self}; + use wormhole::state::{Self}; + use wormhole::transfer_fee::{Self}; + use wormhole::vaa::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + person, + return_clock, + return_state, + set_up_wormhole, + take_clock, + take_state, + two_people, + upgrade_wormhole + }; + + const VAA_TRANSFER_FEE_1: vector = + x"01000000000100a96aee105d7683266d98c9b274eddb20391378adddcefbc7a5266b4be78bc6eb582797741b65617d796c6c613ae7a4dad52a8b4aa4659842dcc4c9b3891549820100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f726504001500000000000000000000000000000000000000000000000000000000000004b0000000000000000000000000000000000000000000000000000000000000b0b2"; + const VAA_TRANSFER_FEE_OVERFLOW: vector = + x"01000000000100529b407a673f8917ccb9bb6f8d46d0f729c1ff845b0068ef5e0a3de464670b2e379a8994b15362785e52d73e01c880dbcdf432ef3702782d17d352fb07ed86830100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f72650400150000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000b0b2"; + const VAA_TRANSFER_FEE_ZERO_ADDRESS: vector = + x"0100000000010032b2ab65a690ae4af8c85903d7b22239fc272183eefdd5a4fa784664f82aa64b381380cc03859156e88623949ce4da4435199aaac1cb09e52a09d6915725a5e70100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f726504001500000000000000000000000000000000000000000000000000000000000004b00000000000000000000000000000000000000000000000000000000000000000"; + + #[test] + fun test_transfer_fee() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let (caller, recipient) = two_people(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Double-check current fee (from setup). + assert!(state::message_fee(&worm_state) == wormhole_fee, 0); + + // Deposit fee several times. + let (i, n) = (0, 8); + while (i < n) { + state::deposit_fee_test_only( + &mut worm_state, + balance::create_for_testing(wormhole_fee) + ); + i = i + 1; + }; + + // Double-check balance. + let total_deposited = n * wormhole_fee; + assert!(state::fees_collected(&worm_state) == total_deposited, 0); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_TRANSFER_FEE_1, &the_clock); + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let withdrawn = + transfer_fee( + &mut worm_state, + receipt, + test_scenario::ctx(scenario) + ); + assert!(withdrawn == 1200, 0); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Verify that the recipient received the withdrawal. + let withdrawn_coin = + test_scenario::take_from_address>(scenario, recipient); + assert!(coin::value(&withdrawn_coin) == withdrawn, 0); + + // And there is still a balance on Wormhole's fee collector. + let remaining = total_deposited - withdrawn; + assert!(state::fees_collected(&worm_state) == remaining, 0); + + // Clean up. + coin::burn_for_testing(withdrawn_coin); + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_transfer_fee_after_upgrade() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Upgrade. + upgrade_wormhole(scenario); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Double-check current fee (from setup). + assert!(state::message_fee(&worm_state) == wormhole_fee, 0); + + // Deposit fee several times. + let (i, n) = (0, 8); + while (i < n) { + state::deposit_fee_test_only( + &mut worm_state, + balance::create_for_testing(wormhole_fee) + ); + i = i + 1; + }; + + // Double-check balance. + let total_deposited = n * wormhole_fee; + assert!(state::fees_collected(&worm_state) == total_deposited, 0); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_TRANSFER_FEE_1, &the_clock); + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let withdrawn = + transfer_fee( + &mut worm_state, + receipt, + test_scenario::ctx(scenario) + ); + assert!(withdrawn == 1200, 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::set::E_KEY_ALREADY_EXISTS)] + fun test_cannot_transfer_fee_with_same_vaa() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Double-check current fee (from setup). + assert!(state::message_fee(&worm_state) == wormhole_fee, 0); + + // Deposit fee several times. + let (i, n) = (0, 8); + while (i < n) { + state::deposit_fee_test_only( + &mut worm_state, + balance::create_for_testing(wormhole_fee) + ); + i = i + 1; + }; + + // Transfer once. + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_TRANSFER_FEE_1, &the_clock); + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + transfer_fee(&mut worm_state, receipt, test_scenario::ctx(scenario)); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_TRANSFER_FEE_1, &the_clock); + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + transfer_fee(&mut worm_state, receipt, test_scenario::ctx(scenario)); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = iota::balance::ENotEnough)] + fun test_cannot_transfer_fee_insufficient_balance() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Show balance is zero. + assert!(state::fees_collected(&worm_state) == 0, 0); + + // Show that the encoded fee is greater than zero. + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_TRANSFER_FEE_1, &the_clock); + let payload = + governance_message::take_decree(vaa::payload(&verified_vaa)); + let cur = cursor::new(payload); + + let amount = bytes::take_u256_be(&mut cur); + assert!(amount > 0, 0); + cursor::take_rest(cur); + + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + transfer_fee(&mut worm_state, receipt, test_scenario::ctx(scenario)); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = external_address::E_ZERO_ADDRESS)] + fun test_cannot_transfer_fee_recipient_zero_address() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Show balance is zero. + assert!(state::fees_collected(&worm_state) == 0, 0); + + // Show that the encoded fee is greater than zero. + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_TRANSFER_FEE_ZERO_ADDRESS, + &the_clock + ); + let payload = + governance_message::take_decree(vaa::payload(&verified_vaa)); + let cur = cursor::new(payload); + + bytes::take_u256_be(&mut cur); + + // Confirm recipient is zero address. + let addr = bytes32::take_bytes(&mut cur); + assert!(!bytes32::is_nonzero(&addr), 0); + cursor::destroy_empty(cur); + + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + transfer_fee(&mut worm_state, receipt, test_scenario::ctx(scenario)); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::bytes32::E_U64_OVERFLOW)] + fun test_cannot_transfer_fee_withdraw_amount_overflow() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Show balance is zero. + assert!(state::fees_collected(&worm_state) == 0, 0); + + // Show that the encoded fee is greater than zero. + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_TRANSFER_FEE_OVERFLOW, + &the_clock + ); + let payload = + governance_message::take_decree(vaa::payload(&verified_vaa)); + let cur = cursor::new(payload); + + let amount = bytes::take_u256_be(&mut cur); + assert!(amount > 0xffffffffffffffff, 0); + cursor::take_rest(cur); + + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + transfer_fee(&mut worm_state, receipt, test_scenario::ctx(scenario)); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_set_fee_outdated_version() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Double-check current fee (from setup). + assert!(state::message_fee(&worm_state) == wormhole_fee, 0); + + // Deposit fee several times. + let (i, n) = (0, 8); + while (i < n) { + state::deposit_fee_test_only( + &mut worm_state, + balance::create_for_testing(wormhole_fee) + ); + i = i + 1; + }; + + // Double-check balance. + let total_deposited = n * wormhole_fee; + assert!(state::fees_collected(&worm_state) == total_deposited, 0); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_TRANSFER_FEE_1, + &the_clock + ); + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + transfer_fee(&mut worm_state, receipt, test_scenario::ctx(scenario)); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance/update_guardian_set.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance/update_guardian_set.move new file mode 100644 index 0000000000..8eb5671236 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance/update_guardian_set.move @@ -0,0 +1,471 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact updating the +/// current guardian set to be a new set of guardian public keys. As a part of +/// this process, the previous guardian set's expiration time is set. Keep in +/// mind that the current guardian set has no expiration. +module wormhole::update_guardian_set { + use std::vector::{Self}; + use iota::clock::{Clock}; + + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + use wormhole::guardian::{Self, Guardian}; + use wormhole::guardian_set::{Self}; + use wormhole::state::{Self, State, LatestOnly}; + + /// No guardians public keys found in VAA. + const E_NO_GUARDIANS: u64 = 0; + /// Guardian set index is not incremented from last known guardian set. + const E_NON_INCREMENTAL_GUARDIAN_SETS: u64 = 1; + + /// Specific governance payload ID (action) for updating the guardian set. + const ACTION_UPDATE_GUARDIAN_SET: u8 = 2; + + struct GovernanceWitness has drop {} + + /// Event reflecting a Guardian Set update. + struct GuardianSetAdded has drop, copy { + new_index: u32 + } + + struct UpdateGuardianSet { + new_index: u32, + guardians: vector, + } + + public fun authorize_governance( + wormhole_state: &State + ): DecreeTicket { + governance_message::authorize_verify_global( + GovernanceWitness {}, + state::governance_chain(wormhole_state), + state::governance_contract(wormhole_state), + state::governance_module(), + ACTION_UPDATE_GUARDIAN_SET + ) + } + + /// Redeem governance VAA to update the current Guardian set with a new + /// set of Guardian public keys. This governance action is applied globally + /// across all networks. + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + public fun update_guardian_set( + wormhole_state: &mut State, + receipt: DecreeReceipt, + the_clock: &Clock + ): u32 { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(wormhole_state); + + // Even though this disallows the VAA to be replayed, it may be + // impossible to redeem the same VAA again because `governance_message` + // requires new governance VAAs being signed by the most recent guardian + // set). + let payload = + governance_message::take_payload( + state::borrow_mut_consumed_vaas(&latest_only, wormhole_state), + receipt + ); + + // Proceed with the update. + handle_update_guardian_set(&latest_only, wormhole_state, payload, the_clock) + } + + fun handle_update_guardian_set( + latest_only: &LatestOnly, + wormhole_state: &mut State, + governance_payload: vector, + the_clock: &Clock + ): u32 { + // Deserialize the payload as the updated guardian set. + let UpdateGuardianSet { + new_index, + guardians + } = deserialize(governance_payload); + + // Every new guardian set index must be incremental from the last known + // guardian set. + assert!( + new_index == state::guardian_set_index(wormhole_state) + 1, + E_NON_INCREMENTAL_GUARDIAN_SETS + ); + + // Expire the existing guardian set. + state::expire_guardian_set(latest_only, wormhole_state, the_clock); + + // And store the new one. + state::add_new_guardian_set( + latest_only, + wormhole_state, + guardian_set::new(new_index, guardians) + ); + + iota::event::emit(GuardianSetAdded { new_index }); + + new_index + } + + fun deserialize(payload: vector): UpdateGuardianSet { + let cur = cursor::new(payload); + let new_index = bytes::take_u32_be(&mut cur); + let num_guardians = bytes::take_u8(&mut cur); + assert!(num_guardians > 0, E_NO_GUARDIANS); + + let guardians = vector::empty(); + let i = 0; + while (i < num_guardians) { + let key = bytes::take_bytes(&mut cur, 20); + vector::push_back(&mut guardians, guardian::new(key)); + i = i + 1; + }; + cursor::destroy_empty(cur); + + UpdateGuardianSet { new_index, guardians } + } + + #[test_only] + public fun action(): u8 { + ACTION_UPDATE_GUARDIAN_SET + } +} + +#[test_only] +module wormhole::update_guardian_set_tests { + use std::vector::{Self}; + use iota::clock::{Self}; + use iota::test_scenario::{Self}; + + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::governance_message::{Self}; + use wormhole::guardian::{Self}; + use wormhole::guardian_set::{Self}; + use wormhole::state::{Self}; + use wormhole::update_guardian_set::{Self}; + use wormhole::vaa::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + person, + return_clock, + return_state, + set_up_wormhole, + take_clock, + take_state, + upgrade_wormhole + }; + + const VAA_UPDATE_GUARDIAN_SET_1: vector = + x"010000000001004f74e9596bd8246ef456918594ae16e81365b52c0cf4490b2a029fb101b058311f4a5592baeac014dc58215faad36453467a85a4c3e1c6cf5166e80f6e4dc50b0100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f72650200000000000113befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe88d7d8b32a9105d228100e72dffe2fae0705d31c58076f561cc62a47087b567c86f986426dfcd000bd6e9833490f8fa87c733a183cd076a6cbd29074b853fcf0a5c78c1b56d15fce7a154e6ebe9ed7a2af3503dbd2e37518ab04d7ce78b630f98b15b78a785632dea5609064803b1c8ea8bb2c77a6004bd109a281a698c0f5ba31f158585b41f4f33659e54d3178443ab76a60e21690dbfb17f7f59f09ae3ea1647ec26ae49b14060660504f4da1c2059e1c5ab6810ac3d8e1258bd2f004a94ca0cd4c68fc1c061180610e96d645b12f47ae5cf4546b18538739e90f2edb0d8530e31a218e72b9480202acbaeb06178da78858e5e5c4705cdd4b668ffe3be5bae4867c9d5efe3a05efc62d60e1d19faeb56a80223cdd3472d791b7d32c05abb1cc00b6381fa0c4928f0c56fc14bc029b8809069093d712a3fd4dfab31963597e246ab29fc6ebedf2d392a51ab2dc5c59d0902a03132a84dfd920b35a3d0ba5f7a0635df298f9033e"; + const VAA_UPDATE_GUARDIAN_SET_2A: vector = + x"010000000001005fb17d5e0e736e3014756bf7e7335722c4fe3ad18b5b1b566e8e61e562cc44555f30b298bc6a21ea4b192a6f1877a5e638ecf90a77b0b028f297a3a70d93614d0100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f72650200000000000101befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe"; + const VAA_UPDATE_GUARDIAN_SET_2B: vector = + x"01000000010100195f37abd29438c74db6e57bf527646b36fa96e36392221e869debe0e911f2f319abc0fd5c5a454da76fc0ffdd23a71a60bca40aa4289a841ad07f2964cde9290000bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000020100000000000000000000000000000000000000000000000000000000436f72650200000000000201befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe"; + const VAA_UPDATE_GUARDIAN_SET_EMPTY: vector = + x"0100000000010098f9e45f836661d2932def9c74c587168f4f75d0282201ee6f5a98557e6212ff19b0f8881c2750646250f60dd5d565530779ecbf9442aa5ffc2d6afd7303aaa40000bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f72650200000000000100"; + + #[test] + fun test_update_guardian_set() { + // Testing this method. + use wormhole::update_guardian_set::{update_guardian_set}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `update_guardian_set`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_1, + &the_clock + ); + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let new_index = + update_guardian_set(&mut worm_state, receipt, &the_clock); + assert!(new_index == 1, 0); + + let new_guardian_set = + state::guardian_set_at(&worm_state, new_index); + + // Verify new guardian set index. + assert!(state::guardian_set_index(&worm_state) == new_index, 0); + assert!( + guardian_set::index(new_guardian_set) == state::guardian_set_index(&worm_state), + 0 + ); + + // Check that the guardians agree with what we expect. + let guardians = guardian_set::guardians(new_guardian_set); + let expected = vector[ + guardian::new(x"befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe"), + guardian::new(x"88d7d8b32a9105d228100e72dffe2fae0705d31c"), + guardian::new(x"58076f561cc62a47087b567c86f986426dfcd000"), + guardian::new(x"bd6e9833490f8fa87c733a183cd076a6cbd29074"), + guardian::new(x"b853fcf0a5c78c1b56d15fce7a154e6ebe9ed7a2"), + guardian::new(x"af3503dbd2e37518ab04d7ce78b630f98b15b78a"), + guardian::new(x"785632dea5609064803b1c8ea8bb2c77a6004bd1"), + guardian::new(x"09a281a698c0f5ba31f158585b41f4f33659e54d"), + guardian::new(x"3178443ab76a60e21690dbfb17f7f59f09ae3ea1"), + guardian::new(x"647ec26ae49b14060660504f4da1c2059e1c5ab6"), + guardian::new(x"810ac3d8e1258bd2f004a94ca0cd4c68fc1c0611"), + guardian::new(x"80610e96d645b12f47ae5cf4546b18538739e90f"), + guardian::new(x"2edb0d8530e31a218e72b9480202acbaeb06178d"), + guardian::new(x"a78858e5e5c4705cdd4b668ffe3be5bae4867c9d"), + guardian::new(x"5efe3a05efc62d60e1d19faeb56a80223cdd3472"), + guardian::new(x"d791b7d32c05abb1cc00b6381fa0c4928f0c56fc"), + guardian::new(x"14bc029b8809069093d712a3fd4dfab31963597e"), + guardian::new(x"246ab29fc6ebedf2d392a51ab2dc5c59d0902a03"), + guardian::new(x"132a84dfd920b35a3d0ba5f7a0635df298f9033e"), + ]; + assert!(vector::length(&expected) == vector::length(guardians), 0); + + let cur = cursor::new(expected); + let i = 0; + while (!cursor::is_empty(&cur)) { + let left = guardian::as_bytes(vector::borrow(guardians, i)); + let right = guardian::to_bytes(cursor::poke(&mut cur)); + assert!(left == right, 0); + i = i + 1; + }; + cursor::destroy_empty(cur); + + // Make sure old guardian set is still active. + let old_guardian_set = + state::guardian_set_at(&worm_state, new_index - 1); + assert!(guardian_set::is_active(old_guardian_set, &the_clock), 0); + + // Fast forward time beyond expiration by + // `guardian_set_seconds_to_live`. + let tick_ms = + (state::guardian_set_seconds_to_live(&worm_state) as u64) * 1000; + clock::increment_for_testing(&mut the_clock, tick_ms + 1); + + // Now the old guardian set should be expired (because in the test setup + // time to live is set to 2 epochs). + assert!(!guardian_set::is_active(old_guardian_set, &the_clock), 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_update_guardian_set_after_upgrade() { + // Testing this method. + use wormhole::update_guardian_set::{update_guardian_set}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Upgrade. + upgrade_wormhole(scenario); + + // Prepare test to execute `update_guardian_set`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_1, + &the_clock + ); + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let new_index = + update_guardian_set(&mut worm_state, receipt, &the_clock); + assert!(new_index == 1, 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_OLD_GUARDIAN_SET_GOVERNANCE + )] + fun test_cannot_update_guardian_set_again_with_same_vaa() { + // Testing this method. + use wormhole::update_guardian_set::{update_guardian_set}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `update_guardian_set`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_2A, + &the_clock + ); + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + update_guardian_set(&mut worm_state, receipt, &the_clock); + + // Update guardian set again with new VAA. + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_2B, + &the_clock + ); + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let new_index = + update_guardian_set(&mut worm_state, receipt, &the_clock); + assert!(new_index == 2, 0); + assert!(state::guardian_set_index(&worm_state) == 2, 0); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_2A, + &the_clock + ); + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + update_guardian_set(&mut worm_state, receipt, &the_clock); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = update_guardian_set::E_NO_GUARDIANS)] + fun test_cannot_update_guardian_set_with_no_guardians() { + // Testing this method. + use wormhole::update_guardian_set::{update_guardian_set}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `update_guardian_set`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + + // Show that the encoded number of guardians is zero. + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_EMPTY, + &the_clock + ); + let payload = + governance_message::take_decree(vaa::payload(&verified_vaa)); + let cur = cursor::new(payload); + + let new_guardian_set_index = bytes::take_u32_be(&mut cur); + assert!(new_guardian_set_index == 1, 0); + + let num_guardians = bytes::take_u8(&mut cur); + assert!(num_guardians == 0, 0); + + cursor::destroy_empty(cur); + + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + update_guardian_set(&mut worm_state, receipt, &the_clock); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_set_fee_outdated_version() { + // Testing this method. + use wormhole::update_guardian_set::{update_guardian_set}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `update_guardian_set`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_1, + &the_clock + ); + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + update_guardian_set(&mut worm_state, receipt, &the_clock); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance/upgrade_contract.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance/upgrade_contract.move new file mode 100644 index 0000000000..89ea8fa7c2 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance/upgrade_contract.move @@ -0,0 +1,126 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact upgrading the +/// Wormhole contract to a new build. The procedure to upgrade this contract +/// requires a Programmable Transaction, which includes the following procedure: +/// 1. Load new build. +/// 2. Authorize upgrade. +/// 3. Upgrade. +/// 4. Commit upgrade. +module wormhole::upgrade_contract { + use iota::object::{ID}; + use iota::package::{UpgradeReceipt, UpgradeTicket}; + + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::cursor::{Self}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + use wormhole::state::{Self, State}; + + friend wormhole::migrate; + + /// Digest is all zeros. + const E_DIGEST_ZERO_BYTES: u64 = 0; + + /// Specific governance payload ID (action) to complete upgrading the + /// contract. + const ACTION_UPGRADE_CONTRACT: u8 = 1; + + struct GovernanceWitness has drop {} + + // Event reflecting package upgrade. + struct ContractUpgraded has drop, copy { + old_contract: ID, + new_contract: ID + } + + struct UpgradeContract { + digest: Bytes32 + } + + public fun authorize_governance( + wormhole_state: &State + ): DecreeTicket { + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(wormhole_state), + state::governance_contract(wormhole_state), + state::governance_module(), + ACTION_UPGRADE_CONTRACT + ) + } + + /// Redeem governance VAA to issue an `UpgradeTicket` for the upgrade given + /// a contract upgrade VAA. This governance message is only relevant for Iota + /// because a contract upgrade is only relevant to one particular network + /// (in this case Iota), whose build digest is encoded in this message. + public fun authorize_upgrade( + wormhole_state: &mut State, + receipt: DecreeReceipt + ): UpgradeTicket { + // NOTE: This is the only governance method that does not enforce + // current package checking when consuming VAA hashes. This is because + // upgrades are protected by the Iota VM, enforcing the latest package + // is the one performing the upgrade. + let consumed = + state::borrow_mut_consumed_vaas_unchecked(wormhole_state); + + // And consume. + let payload = governance_message::take_payload(consumed, receipt); + + // Proceed with processing new implementation version. + handle_upgrade_contract(wormhole_state, payload) + } + + /// Finalize the upgrade that ran to produce the given `receipt`. This + /// method invokes `state::commit_upgrade` which interacts with + /// `iota::package`. + public fun commit_upgrade( + self: &mut State, + receipt: UpgradeReceipt, + ) { + let (old_contract, new_contract) = state::commit_upgrade(self, receipt); + + // Emit an event reflecting package ID change. + iota::event::emit(ContractUpgraded { old_contract, new_contract }); + } + + /// Privileged method only to be used by this module and `migrate` module. + /// + /// During migration, we make sure that the digest equals what we expect by + /// passing in the same VAA used to upgrade the package. + public(friend) fun take_digest(governance_payload: vector): Bytes32 { + // Deserialize the payload as the build digest. + let UpgradeContract { digest } = deserialize(governance_payload); + + digest + } + + fun handle_upgrade_contract( + wormhole_state: &mut State, + payload: vector + ): UpgradeTicket { + state::authorize_upgrade(wormhole_state, take_digest(payload)) + } + + fun deserialize(payload: vector): UpgradeContract { + let cur = cursor::new(payload); + + // This amount cannot be greater than max u64. + let digest = bytes32::take_bytes(&mut cur); + assert!(bytes32::is_nonzero(&digest), E_DIGEST_ZERO_BYTES); + + cursor::destroy_empty(cur); + + UpgradeContract { digest } + } + + #[test_only] + public fun action(): u8 { + ACTION_UPGRADE_CONTRACT + } +} + +#[test_only] +module wormhole::upgrade_contract_tests { + // TODO +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance_message.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance_message.move new file mode 100644 index 0000000000..a28ac2c80f --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/governance_message.move @@ -0,0 +1,694 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type representing a Guardian governance +/// action. Each governance action has an associated module name, relevant chain +/// and payload encoding instructions/data used to perform an administrative +/// change on a contract. +module wormhole::governance_message { + use wormhole::bytes::{Self}; + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::consumed_vaas::{Self, ConsumedVAAs}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{ExternalAddress}; + use wormhole::state::{Self, State, chain_id}; + use wormhole::vaa::{Self, VAA}; + + /// Guardian set used to sign VAA did not use current Guardian set. + const E_OLD_GUARDIAN_SET_GOVERNANCE: u64 = 0; + /// Governance chain does not match. + const E_INVALID_GOVERNANCE_CHAIN: u64 = 1; + /// Governance emitter address does not match. + const E_INVALID_GOVERNANCE_EMITTER: u64 = 2; + /// Governance module name does not match. + const E_INVALID_GOVERNANCE_MODULE: u64 = 4; + /// Governance action does not match. + const E_INVALID_GOVERNANCE_ACTION: u64 = 5; + /// Governance target chain not indicative of global action. + const E_GOVERNANCE_TARGET_CHAIN_NONZERO: u64 = 6; + /// Governance target chain not indicative of actino specifically for Iota + /// Wormhole contract. + const E_GOVERNANCE_TARGET_CHAIN_NOT_SUI: u64 = 7; + + /// The public constructors for `DecreeTicket` (`authorize_verify_global` + /// and `authorize_verify_local`) require a witness of type `T`. This is to + /// ensure that `DecreeTicket`s cannot be mixed up between modules + /// maliciously. + struct DecreeTicket { + governance_chain: u16, + governance_contract: ExternalAddress, + module_name: Bytes32, + action: u8, + global: bool + } + + struct DecreeReceipt { + payload: vector, + digest: Bytes32, + sequence: u64 + } + + /// This method prepares `DecreeTicket` for global governance action. This + /// means the VAA encodes target chain ID == 0. + public fun authorize_verify_global( + _witness: T, + governance_chain: u16, + governance_contract: ExternalAddress, + module_name: Bytes32, + action: u8 + ): DecreeTicket { + DecreeTicket { + governance_chain, + governance_contract, + module_name, + action, + global: true + } + } + + /// This method prepares `DecreeTicket` for local governance action. This + /// means the VAA encodes target chain ID == 21 (Iota's). + public fun authorize_verify_local( + _witness: T, + governance_chain: u16, + governance_contract: ExternalAddress, + module_name: Bytes32, + action: u8 + ): DecreeTicket { + DecreeTicket { + governance_chain, + governance_contract, + module_name, + action, + global: false + } + } + + public fun sequence(receipt: &DecreeReceipt): u64 { + receipt.sequence + } + + /// This method unpacks `DecreeReceipt` and puts the VAA digest into a + /// `ConsumedVAAs` container. Then it returns the governance payload. + public fun take_payload( + consumed: &mut ConsumedVAAs, + receipt: DecreeReceipt + ): vector { + let DecreeReceipt { payload, digest, sequence: _ } = receipt; + + consumed_vaas::consume(consumed, digest); + + payload + } + + /// Method to peek into the payload in `DecreeReceipt`. + public fun payload(receipt: &DecreeReceipt): vector { + receipt.payload + } + + /// Destroy the receipt. + public fun destroy(receipt: DecreeReceipt) { + let DecreeReceipt { payload: _, digest: _, sequence: _ } = receipt; + } + + /// This method unpacks a `DecreeTicket` to validate its members to make + /// sure that the parameters match what was encoded in the VAA. + public fun verify_vaa( + wormhole_state: &State, + verified_vaa: VAA, + ticket: DecreeTicket + ): DecreeReceipt { + state::assert_latest_only(wormhole_state); + + let DecreeTicket { + governance_chain, + governance_contract, + module_name, + action, + global + } = ticket; + + // Protect against governance actions enacted using an old guardian set. + // This is not a protection found in the other Wormhole contracts. + assert!( + vaa::guardian_set_index(&verified_vaa) == state::guardian_set_index(wormhole_state), + E_OLD_GUARDIAN_SET_GOVERNANCE + ); + + // Both the emitter chain and address must equal. + assert!( + vaa::emitter_chain(&verified_vaa) == governance_chain, + E_INVALID_GOVERNANCE_CHAIN + ); + assert!( + vaa::emitter_address(&verified_vaa) == governance_contract, + E_INVALID_GOVERNANCE_EMITTER + ); + + // Cache VAA digest. + let digest = vaa::digest(&verified_vaa); + + // Get the VAA sequence number. + let sequence = vaa::sequence(&verified_vaa); + + // Finally deserialize Wormhole payload as governance message. + let ( + parsed_module_name, + parsed_action, + chain, + payload + ) = deserialize(vaa::take_payload(verified_vaa)); + + assert!(module_name == parsed_module_name, E_INVALID_GOVERNANCE_MODULE); + assert!(action == parsed_action, E_INVALID_GOVERNANCE_ACTION); + + // Target chain, which determines whether the governance VAA applies to + // all chains or Iota. + if (global) { + assert!(chain == 0, E_GOVERNANCE_TARGET_CHAIN_NONZERO); + } else { + assert!(chain == chain_id(), E_GOVERNANCE_TARGET_CHAIN_NOT_SUI); + }; + + DecreeReceipt { payload, digest, sequence } + } + + fun deserialize(buf: vector): (Bytes32, u8, u16, vector) { + let cur = cursor::new(buf); + + ( + bytes32::take_bytes(&mut cur), + bytes::take_u8(&mut cur), + bytes::take_u16_be(&mut cur), + cursor::take_rest(cur) + ) + } + + #[test_only] + public fun deserialize_test_only( + buf: vector + ): ( + Bytes32, + u8, + u16, + vector + ) { + deserialize(buf) + } + + #[test_only] + public fun take_decree(buf: vector): vector { + let (_, _, _, payload) = deserialize(buf); + payload + } +} + +#[test_only] +module wormhole::governance_message_tests { + use iota::test_scenario::{Self}; + use iota::tx_context::{Self}; + + use wormhole::bytes32::{Self}; + use wormhole::consumed_vaas::{Self}; + use wormhole::external_address::{Self}; + use wormhole::governance_message::{Self}; + use wormhole::state::{Self}; + use wormhole::vaa::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + set_up_wormhole, + person, + return_clock, + return_state, + take_clock, + take_state + }; + + struct GovernanceWitness has drop {} + + const VAA_UPDATE_GUARDIAN_SET_1: vector = + x"010000000001004f74e9596bd8246ef456918594ae16e81365b52c0cf4490b2a029fb101b058311f4a5592baeac014dc58215faad36453467a85a4c3e1c6cf5166e80f6e4dc50b0100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f72650200000000000113befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe88d7d8b32a9105d228100e72dffe2fae0705d31c58076f561cc62a47087b567c86f986426dfcd000bd6e9833490f8fa87c733a183cd076a6cbd29074b853fcf0a5c78c1b56d15fce7a154e6ebe9ed7a2af3503dbd2e37518ab04d7ce78b630f98b15b78a785632dea5609064803b1c8ea8bb2c77a6004bd109a281a698c0f5ba31f158585b41f4f33659e54d3178443ab76a60e21690dbfb17f7f59f09ae3ea1647ec26ae49b14060660504f4da1c2059e1c5ab6810ac3d8e1258bd2f004a94ca0cd4c68fc1c061180610e96d645b12f47ae5cf4546b18538739e90f2edb0d8530e31a218e72b9480202acbaeb06178da78858e5e5c4705cdd4b668ffe3be5bae4867c9d5efe3a05efc62d60e1d19faeb56a80223cdd3472d791b7d32c05abb1cc00b6381fa0c4928f0c56fc14bc029b8809069093d712a3fd4dfab31963597e246ab29fc6ebedf2d392a51ab2dc5c59d0902a03132a84dfd920b35a3d0ba5f7a0635df298f9033e"; + const VAA_SET_FEE_1: vector = + x"01000000000100181aa27fd44f3060fad0ae72895d42f97c45f7a5d34aa294102911370695e91e17ae82caa59f779edde2356d95cd46c2c381cdeba7a8165901a562374f212d750000bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f7265030015000000000000000000000000000000000000000000000000000000000000015e"; + + #[test] + fun test_global_action() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_1, + &the_clock + ); + let ( + _, + _, + _, + expected_payload + ) = governance_message::deserialize_test_only( + vaa::payload(&verified_vaa) + ); + + let ticket = + governance_message::authorize_verify_global( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + state::governance_module(), + 2 // update guadian set + ); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + let consumed = consumed_vaas::new(&mut tx_context::dummy()); + let payload = governance_message::take_payload(&mut consumed, receipt); + assert!(payload == expected_payload, 0); + + // Clean up. + consumed_vaas::destroy(consumed); + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_local_action() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ( + _, + _, + _, + expected_payload + ) = governance_message::deserialize_test_only( + vaa::payload(&verified_vaa) + ); + + let ticket = + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + state::governance_module(), + 3 // set fee + ); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + let consumed = consumed_vaas::new(&mut tx_context::dummy()); + let payload = governance_message::take_payload(&mut consumed, receipt); + assert!(payload == expected_payload, 0); + + // Clean up. + consumed_vaas::destroy(consumed); + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_INVALID_GOVERNANCE_CHAIN + )] + fun test_cannot_verify_vaa_invalid_governance_chain() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + + // Show that this emitter chain ID does not equal the encoded one. + let invalid_chain = 0xffff; + assert!(invalid_chain != vaa::emitter_chain(&verified_vaa), 0); + + let ticket = + governance_message::authorize_verify_local( + GovernanceWitness {}, + invalid_chain, + state::governance_contract(&worm_state), + state::governance_module(), + 3 // set fee + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_INVALID_GOVERNANCE_EMITTER + )] + fun test_cannot_verify_vaa_invalid_governance_emitter() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + + // Show that this emitter address does not equal the encoded one. + let invalid_emitter = external_address::new(bytes32::default()); + assert!(invalid_emitter != vaa::emitter_address(&verified_vaa), 0); + + let ticket = + governance_message::authorize_verify_global( + GovernanceWitness {}, + state::governance_chain(&worm_state), + invalid_emitter, + state::governance_module(), + 3 // set fee + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_INVALID_GOVERNANCE_MODULE + )] + fun test_cannot_verify_vaa_invalid_governance_module() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ( + expected_module, + _, + _, + _ + ) = governance_message::deserialize_test_only( + vaa::payload(&verified_vaa) + ); + + // Show that this module does not equal the encoded one. + let invalid_module = bytes32::from_bytes(b"Not Wormhole"); + assert!(invalid_module != expected_module, 0); + + let ticket = + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + invalid_module, + 3 // set fee + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_INVALID_GOVERNANCE_ACTION + )] + fun test_cannot_verify_vaa_invalid_governance_action() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ( + _, + expected_action, + _, + _ + ) = governance_message::deserialize_test_only( + vaa::payload(&verified_vaa) + ); + + // Show that this action does not equal the encoded one. + let invalid_action = 0xff; + assert!(invalid_action != expected_action, 0); + + let ticket = + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + state::governance_module(), + invalid_action + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_GOVERNANCE_TARGET_CHAIN_NONZERO + )] + fun test_cannot_verify_vaa_governance_target_chain_nonzero() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ( + _, + _, + expected_target_chain, + _ + ) = governance_message::deserialize_test_only( + vaa::payload(&verified_vaa) + ); + + // Show that this target chain ID does reflect a global action. + let not_global = expected_target_chain != 0; + assert!(not_global, 0); + + let ticket = + governance_message::authorize_verify_global( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + state::governance_module(), + 3 // set fee + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_GOVERNANCE_TARGET_CHAIN_NOT_SUI + )] + fun test_cannot_verify_vaa_governance_target_chain_not_sui() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_1, + &the_clock + ); + let ( + _, + _, + expected_target_chain, + _ + ) = governance_message::deserialize_test_only( + vaa::payload(&verified_vaa) + ); + + // Show that this target chain ID does reflect a global action. + let global = expected_target_chain == 0; + assert!(global, 0); + + let ticket = + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + state::governance_module(), + 2 // update guardian set + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_verify_vaa_outdated_version() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ticket = + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + state::governance_module(), + 3 // set fee + ); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/migrate.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/migrate.move new file mode 100644 index 0000000000..5003e16c02 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/migrate.move @@ -0,0 +1,220 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a public method intended to be called after an +/// upgrade has been committed. The purpose is to add one-off migration logic +/// that would alter Wormhole `State`. +/// +/// Included in migration is the ability to ensure that breaking changes for +/// any of Wormhole's methods by enforcing the current build version as their +/// required minimum version. +module wormhole::migrate { + use iota::clock::{Clock}; + use iota::object::{ID}; + + use wormhole::governance_message::{Self}; + use wormhole::state::{Self, State}; + use wormhole::upgrade_contract::{Self}; + use wormhole::vaa::{Self}; + + /// Event reflecting when `migrate` is successfully executed. + struct MigrateComplete has drop, copy { + package: ID + } + + /// Execute migration logic. See `wormhole::migrate` description for more + /// info. + public fun migrate( + wormhole_state: &mut State, + upgrade_vaa_buf: vector, + the_clock: &Clock + ) { + state::migrate__v__0_2_0(wormhole_state); + + // Perform standard migrate. + handle_migrate(wormhole_state, upgrade_vaa_buf, the_clock); + + //////////////////////////////////////////////////////////////////////// + // + // NOTE: Put any one-off migration logic here. + // + // Most upgrades likely won't need to do anything, in which case the + // rest of this function's body may be empty. Make sure to delete it + // after the migration has gone through successfully. + // + // WARNING: The migration does *not* proceed atomically with the + // upgrade (as they are done in separate transactions). + // If the nature of this migration absolutely requires the migration to + // happen before certain other functionality is available, then guard + // that functionality with the `assert!` from above. + // + //////////////////////////////////////////////////////////////////////// + + //////////////////////////////////////////////////////////////////////// + } + + fun handle_migrate( + wormhole_state: &mut State, + upgrade_vaa_buf: vector, + the_clock: &Clock + ) { + // Update the version first. + // + // See `version_control` module for hard-coded configuration. + state::migrate_version(wormhole_state); + + // This VAA needs to have been used for upgrading this package. + // + // NOTE: All of the following methods have protections to make sure that + // the current build is used. Given that we officially migrated the + // version as the first call of `migrate`, these should be successful. + + // First we need to check that `parse_and_verify` still works. + let verified_vaa = + vaa::parse_and_verify(wormhole_state, upgrade_vaa_buf, the_clock); + + // And governance methods. + let ticket = upgrade_contract::authorize_governance(wormhole_state); + let receipt = + governance_message::verify_vaa( + wormhole_state, + verified_vaa, + ticket + ); + + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(wormhole_state); + + // Check if build digest is the current one. + let digest = + upgrade_contract::take_digest( + governance_message::payload(&receipt) + ); + state::assert_authorized_digest(&latest_only, wormhole_state, digest); + governance_message::destroy(receipt); + + // Finally emit an event reflecting a successful migrate. + let package = state::current_package(&latest_only, wormhole_state); + iota::event::emit(MigrateComplete { package }); + } + + #[test_only] + public fun set_up_migrate(wormhole_state: &mut State) { + state::reverse_migrate__v__dummy(wormhole_state); + } +} + +#[test_only] +module wormhole::migrate_tests { + use iota::test_scenario::{Self}; + + use wormhole::state::{Self}; + use wormhole::wormhole_scenario::{ + person, + return_clock, + return_state, + set_up_wormhole, + take_clock, + take_state, + upgrade_wormhole + }; + + const UPGRADE_VAA: vector = + x"01000000000100db695668c0c91f4df6e4106dcb912d9062898fd976d631ff1c1b4109ccd203b43cd2419c7d9a191f8d42a780419e63307aacc93080d8629c6c03061c52becf1d0100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f726501001500000000000000000000000000000000000000000000006e6577206275696c64"; + + #[test] + fun test_migrate() { + use wormhole::migrate::{migrate}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole. + let wormhole_message_fee = 350; + set_up_wormhole(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + // Upgrade (digest is just b"new build") for testing purposes. + upgrade_wormhole(scenario); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Set up migrate (which prepares this package to be the same state as + // a previous release). + wormhole::migrate::set_up_migrate(&mut worm_state); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + migrate(&mut worm_state, UPGRADE_VAA, &the_clock); + + // Make sure we emitted an event. + let effects = test_scenario::next_tx(scenario, user); + assert!(test_scenario::num_user_events(&effects) == 1, 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_INCORRECT_OLD_VERSION)] + /// ^ This expected error may change depending on the migration. In most + /// cases, this will abort with `wormhole::package_utils::E_INCORRECT_OLD_VERSION`. + fun test_cannot_migrate_again() { + use wormhole::migrate::{migrate}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole. + let wormhole_message_fee = 350; + set_up_wormhole(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + // Upgrade (digest is just b"new build") for testing purposes. + upgrade_wormhole(scenario); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Set up migrate (which prepares this package to be the same state as + // a previous release). + wormhole::migrate::set_up_migrate(&mut worm_state); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + migrate(&mut worm_state, UPGRADE_VAA, &the_clock); + + // Make sure we emitted an event. + let effects = test_scenario::next_tx(scenario, user); + assert!(test_scenario::num_user_events(&effects) == 1, 0); + + // You shall not pass! + migrate(&mut worm_state, UPGRADE_VAA, &the_clock); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/publish_message.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/publish_message.move new file mode 100644 index 0000000000..cd6cd2c6df --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/publish_message.move @@ -0,0 +1,426 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements two methods: `prepare_message` and `publish_message`, +/// which are to be executed in a transaction block in this order. +/// +/// `prepare_message` allows a contract to pack Wormhole message info (payload +/// that has meaning to an integrator plus nonce) in preparation to publish a +/// `WormholeMessage` event via `publish_message`. Only the owner of an +/// `EmitterCap` has the capability of creating this `MessageTicket`. +/// +/// `publish_message` unpacks the `MessageTicket` and emits a +/// `WormholeMessage` with this message info and timestamp. This event is +/// observed by the Guardian network. +/// +/// The purpose of splitting this message publishing into two steps is in case +/// Wormhole needs to be upgraded and there is a breaking change for this +/// module, an integrator would not be left broken. It is discouraged to put +/// `publish_message` in an integrator's package logic. Otherwise, this +/// integrator needs to be prepared to upgrade his contract to handle the latest +/// version of `publish_message`. +/// +/// Instead, an integtrator is encouraged to execute a transaction block, which +/// executes `publish_message` using the latest Wormhole package ID and to +/// implement `prepare_message` in his contract to produce `MessageTicket`, +/// which `publish_message` consumes. +module wormhole::publish_message { + use iota::coin::{Self, Coin}; + use iota::clock::{Self, Clock}; + use iota::object::{Self, ID}; + use iota::iota::{IOTA}; + + use wormhole::emitter::{Self, EmitterCap}; + use wormhole::state::{Self, State}; + + /// This type is emitted via `iota::event` module. Guardians pick up this + /// observation and attest to its existence. + struct WormholeMessage has drop, copy { + /// `EmitterCap` object ID. + sender: ID, + /// From `EmitterCap`. + sequence: u64, + /// A.K.A. Batch ID. + nonce: u32, + /// Arbitrary message data relevant to integrator. + payload: vector, + /// This will always be `0`. + consistency_level: u8, + /// `Clock` timestamp. + timestamp: u64 + } + + /// This type represents Wormhole message data. The sender is the object ID + /// of an `EmitterCap`, who acts as the capability of creating this type. + /// The only way to destroy this type is calling `publish_message` with + /// a fee to emit a `WormholeMessage` with the unpacked members of this + /// struct. + struct MessageTicket { + /// `EmitterCap` object ID. + sender: ID, + /// From `EmitterCap`. + sequence: u64, + /// A.K.A. Batch ID. + nonce: u32, + /// Arbitrary message data relevant to integrator. + payload: vector + } + + /// `prepare_message` constructs Wormhole message parameters. An + /// `EmitterCap` provides the capability to send an arbitrary payload. + /// + /// NOTE: Integrators of Wormhole should be calling only this method from + /// their contracts. This method is not guarded by version control (thus not + /// requiring a reference to the Wormhole `State` object), so it is intended + /// to work for any package version. + public fun prepare_message( + emitter_cap: &mut EmitterCap, + nonce: u32, + payload: vector + ): MessageTicket { + // Produce sequence number for this message. This will also be the + // return value for this method. + let sequence = emitter::use_sequence(emitter_cap); + + MessageTicket { + sender: object::id(emitter_cap), + sequence, + nonce, + payload + } + } + + /// `publish_message` emits a message as a Iota event. This method uses the + /// input `EmitterCap` as the registered sender of the + /// `WormholeMessage`. It also produces a new sequence for this emitter. + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + /// + /// It is important for integrators to refrain from calling this method + /// within their contracts. This method is meant to be called in a + /// transaction block after receiving a `MessageTicket` from calling + /// `prepare_message` within a contract. If in a circumstance where this + /// module has a breaking change in an upgrade, `prepare_message` will not + /// be affected by this change. + /// + /// See `prepare_message` for more details. + public fun publish_message( + wormhole_state: &mut State, + message_fee: Coin, + prepared_msg: MessageTicket, + the_clock: &Clock + ): u64 { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(wormhole_state); + + // Deposit `message_fee`. This method interacts with the `FeeCollector`, + // which will abort if `message_fee` does not equal the collector's + // expected fee amount. + state::deposit_fee( + &latest_only, + wormhole_state, + coin::into_balance(message_fee) + ); + + let MessageTicket { + sender, + sequence, + nonce, + payload + } = prepared_msg; + + // Truncate to seconds. + let timestamp = clock::timestamp_ms(the_clock) / 1000; + + // Iota is an instant finality chain, so we don't need confirmations. + let consistency_level = 0; + + // Emit Iota event with `WormholeMessage`. + iota::event::emit( + WormholeMessage { + sender, + sequence, + nonce, + payload, + consistency_level, + timestamp + } + ); + + // Done. + sequence + } + + #[test_only] + public fun destroy(prepared_msg: MessageTicket) { + let MessageTicket { + sender: _, + sequence: _, + nonce: _, + payload: _ + } = prepared_msg; + } +} + +#[test_only] +module wormhole::publish_message_tests { + use iota::coin::{Self}; + use iota::test_scenario::{Self}; + + use wormhole::emitter::{Self, EmitterCap}; + use wormhole::fee_collector::{Self}; + use wormhole::state::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + person, + return_clock, + return_state, + set_up_wormhole, + take_clock, + take_state, + upgrade_wormhole + }; + + #[test] + /// This test verifies that `publish_message` is successfully called when + /// the specified message fee is used. + fun test_publish_message() { + use wormhole::publish_message::{prepare_message, publish_message}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + let wormhole_message_fee = 100000000; + + // Initialize Wormhole. + set_up_wormhole(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + { + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // User needs an `EmitterCap` so he can send a message. + let emitter_cap = + wormhole::emitter::new( + &worm_state, + test_scenario::ctx(scenario) + ); + + // Check for event corresponding to new emitter. + let effects = test_scenario::next_tx(scenario, user); + assert!(test_scenario::num_user_events(&effects) == 1, 0); + + // Prepare message. + let msg = + prepare_message( + &mut emitter_cap, + 0, // nonce + b"Hello World" + ); + + // Finally publish Wormhole message. + let sequence = + publish_message( + &mut worm_state, + coin::mint_for_testing( + wormhole_message_fee, + test_scenario::ctx(scenario) + ), + msg, + &the_clock + ); + assert!(sequence == 0, 0); + + // Prepare another message. + let msg = + prepare_message( + &mut emitter_cap, + 0, // nonce + b"Hello World... again" + ); + + // Publish again to check sequence uptick. + let another_sequence = + publish_message( + &mut worm_state, + coin::mint_for_testing( + wormhole_message_fee, + test_scenario::ctx(scenario) + ), + msg, + &the_clock + ); + assert!(another_sequence == 1, 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + iota::transfer::public_transfer(emitter_cap, user); + }; + + // Grab the `TransactionEffects` of the previous transaction. + let effects = test_scenario::next_tx(scenario, user); + + // We expect two events (the Wormhole messages). `test_scenario` does + // not give us an in-depth view of the event specifically. But we can + // check that there was an event associated with the previous + // transaction. + assert!(test_scenario::num_user_events(&effects) == 2, 0); + + // Simulate upgrade and confirm that publish message still works. + { + upgrade_wormhole(scenario); + + // Ignore effects from upgrade. + test_scenario::next_tx(scenario, user); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + let emitter_cap = + test_scenario::take_from_sender(scenario); + + let msg = + prepare_message( + &mut emitter_cap, + 0, // nonce + b"Hello?" + ); + + let sequence = + publish_message( + &mut worm_state, + coin::mint_for_testing( + wormhole_message_fee, + test_scenario::ctx(scenario) + ), + msg, + &the_clock + ); + assert!(sequence == 2, 0); + + // Clean up. + test_scenario::return_to_sender(scenario, emitter_cap); + return_state(worm_state); + return_clock(the_clock); + }; + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = fee_collector::E_INCORRECT_FEE)] + /// This test verifies that `publish_message` fails when the fee is not the + /// correct amount. `FeeCollector` will be the reason for this abort. + fun test_cannot_publish_message_with_incorrect_fee() { + use wormhole::publish_message::{prepare_message, publish_message}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + let wormhole_message_fee = 100000000; + let wrong_fee_amount = wormhole_message_fee - 1; + + // Initialize Wormhole. + set_up_wormhole(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // User needs an `EmitterCap` so he can send a message. + let emitter_cap = + emitter::new(&worm_state, test_scenario::ctx(scenario)); + + let msg = + prepare_message( + &mut emitter_cap, + 0, // nonce + b"Hello World" + ); + // You shall not pass! + publish_message( + &mut worm_state, + coin::mint_for_testing( + wrong_fee_amount, + test_scenario::ctx(scenario) + ), + msg, + &the_clock + ); + + // Clean up. + emitter::destroy_test_only(emitter_cap); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + /// This test verifies that `publish_message` will fail if the minimum + /// required version is greater than the current build's. + fun test_cannot_publish_message_outdated_version() { + use wormhole::publish_message::{prepare_message, publish_message}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + let wormhole_message_fee = 100000000; + + // Initialize Wormhole. + set_up_wormhole(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // User needs an `EmitterCap` so he can send a message. + let emitter_cap = + emitter::new(&worm_state, test_scenario::ctx(scenario)); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + let msg = + prepare_message( + &mut emitter_cap, + 0, // nonce + b"Hello World", + ); + + // You shall not pass! + publish_message( + &mut worm_state, + coin::mint_for_testing( + wormhole_message_fee, + test_scenario::ctx(scenario) + ), + msg, + &the_clock + ); + + // Clean up. + emitter::destroy_test_only(emitter_cap); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/consumed_vaas.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/consumed_vaas.move new file mode 100644 index 0000000000..eeb16a8f38 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/consumed_vaas.move @@ -0,0 +1,29 @@ +module wormhole::consumed_vaas { + use iota::tx_context::{TxContext}; + + use wormhole::bytes32::{Bytes32}; + use wormhole::set::{Self, Set}; + + /// Container storing VAA hashes (digests). This will be checked against in + /// `parse_verify_and_consume` so a particular VAA cannot be replayed. It + /// is up to the integrator to have this container live in his contract + /// in order to take advantage of this no-replay protection. Or an + /// integrator can implement his own method to prevent replay. + struct ConsumedVAAs has store { + hashes: Set + } + + public fun new(ctx: &mut TxContext): ConsumedVAAs { + ConsumedVAAs { hashes: set::new(ctx) } + } + + public fun consume(self: &mut ConsumedVAAs, digest: Bytes32) { + set::add(&mut self.hashes, digest); + } + + #[test_only] + public fun destroy(consumed: ConsumedVAAs) { + let ConsumedVAAs { hashes } = consumed; + set::destroy(hashes); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/fee_collector.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/fee_collector.move new file mode 100644 index 0000000000..c9d91533cf --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/fee_collector.move @@ -0,0 +1,170 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a container that collects fees in IOTA denomination. +/// The `FeeCollector` requires that the fee deposited is exactly equal to the +/// `fee_amount` configured. +module wormhole::fee_collector { + use iota::balance::{Self, Balance}; + use iota::coin::{Self, Coin}; + use iota::iota::{IOTA}; + use iota::tx_context::{TxContext}; + + /// Amount deposited is not exactly the amount configured. + const E_INCORRECT_FEE: u64 = 0; + + /// Container for configured `fee_amount` and `balance` of IOTA collected. + struct FeeCollector has store { + fee_amount: u64, + balance: Balance + } + + /// Create new `FeeCollector` with specified amount to collect. + public fun new(fee_amount: u64): FeeCollector { + FeeCollector { fee_amount, balance: balance::zero() } + } + + /// Retrieve configured amount to collect. + public fun fee_amount(self: &FeeCollector): u64 { + self.fee_amount + } + + /// Retrieve current IOTA balance. + public fun balance_value(self: &FeeCollector): u64 { + balance::value(&self.balance) + } + + /// Take `Balance` and add it to current collected balance. + public fun deposit_balance(self: &mut FeeCollector, fee: Balance) { + assert!(balance::value(&fee) == self.fee_amount, E_INCORRECT_FEE); + balance::join(&mut self.balance, fee); + } + + /// Take `Coin` and add it to current collected balance. + public fun deposit(self: &mut FeeCollector, fee: Coin) { + deposit_balance(self, coin::into_balance(fee)) + } + + /// Create `Balance` of some `amount` by taking from collected balance. + public fun withdraw_balance( + self: &mut FeeCollector, + amount: u64 + ): Balance { + // This will trigger `iota::balance::ENotEnough` if amount > balance. + balance::split(&mut self.balance, amount) + } + + /// Create `Coin` of some `amount` by taking from collected balance. + public fun withdraw( + self: &mut FeeCollector, + amount: u64, + ctx: &mut TxContext + ): Coin { + coin::from_balance(withdraw_balance(self, amount), ctx) + } + + /// Re-configure current `fee_amount`. + public fun change_fee(self: &mut FeeCollector, new_amount: u64) { + self.fee_amount = new_amount; + } + + #[test_only] + public fun destroy(collector: FeeCollector) { + let FeeCollector { fee_amount: _, balance: bal } = collector; + balance::destroy_for_testing(bal); + } +} + +#[test_only] +module wormhole::fee_collector_tests { + use iota::coin::{Self}; + use iota::tx_context::{Self}; + + use wormhole::fee_collector::{Self}; + + #[test] + public fun test_fee_collector() { + let ctx = &mut tx_context::dummy(); + + let fee_amount = 350; + let collector = fee_collector::new(fee_amount); + + // We expect the fee_amount to be the same as what we specified and + // no balance on `FeeCollector` yet. + assert!(fee_collector::fee_amount(&collector) == fee_amount, 0); + assert!(fee_collector::balance_value(&collector) == 0, 0); + + // Deposit fee once. + let fee = coin::mint_for_testing(fee_amount, ctx); + fee_collector::deposit(&mut collector, fee); + assert!(fee_collector::balance_value(&collector) == fee_amount, 0); + + // Now deposit nine more times and check the aggregate balance. + let i = 0; + while (i < 9) { + let fee = coin::mint_for_testing(fee_amount, ctx); + fee_collector::deposit(&mut collector, fee); + i = i + 1; + }; + let total = fee_collector::balance_value(&collector); + assert!(total == 10 * fee_amount, 0); + + // Withdraw a fifth. + let withdraw_amount = total / 5; + let withdrawn = + fee_collector::withdraw(&mut collector, withdraw_amount, ctx); + assert!(coin::value(&withdrawn) == withdraw_amount, 0); + coin::burn_for_testing(withdrawn); + + let remaining = fee_collector::balance_value(&collector); + assert!(remaining == total - withdraw_amount, 0); + + // Withdraw remaining. + let withdrawn = fee_collector::withdraw(&mut collector, remaining, ctx); + assert!(coin::value(&withdrawn) == remaining, 0); + coin::burn_for_testing(withdrawn); + + // There shouldn't be anything left in `FeeCollector`. + assert!(fee_collector::balance_value(&collector) == 0, 0); + + // Done. + fee_collector::destroy(collector); + } + + #[test] + #[expected_failure(abort_code = fee_collector::E_INCORRECT_FEE)] + public fun test_cannot_deposit_incorrect_fee() { + let ctx = &mut tx_context::dummy(); + + let fee_amount = 350; + let collector = fee_collector::new(fee_amount); + + // You shall not pass! + let fee = coin::mint_for_testing(fee_amount + 1, ctx); + fee_collector::deposit(&mut collector, fee); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = iota::balance::ENotEnough)] + public fun test_cannot_withdraw_more_than_balance() { + let ctx = &mut tx_context::dummy(); + + let fee_amount = 350; + let collector = fee_collector::new(fee_amount); + + // Deposit once. + let fee = coin::mint_for_testing(fee_amount, ctx); + fee_collector::deposit(&mut collector, fee); + + // Attempt to withdraw more than the balance. + let bal = fee_collector::balance_value(&collector); + let withdrawn = + fee_collector::withdraw(&mut collector, bal + 1, ctx); + + // Shouldn't get here. But we need to clean up anyway. + coin::burn_for_testing(withdrawn); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/guardian.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/guardian.move new file mode 100644 index 0000000000..73f82631e3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/guardian.move @@ -0,0 +1,83 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a `Guardian` that warehouses a 20-byte public key. +module wormhole::guardian { + use std::vector::{Self}; + use iota::hash::{Self}; + use iota::ecdsa_k1::{Self}; + + use wormhole::bytes20::{Self, Bytes20}; + use wormhole::guardian_signature::{Self, GuardianSignature}; + + /// Guardian public key is all zeros. + const E_ZERO_ADDRESS: u64 = 1; + + /// Container for 20-byte Guardian public key. + struct Guardian has store { + pubkey: Bytes20 + } + + /// Create new `Guardian` ensuring that the input is not all zeros. + public fun new(pubkey: vector): Guardian { + let data = bytes20::new(pubkey); + assert!(bytes20::is_nonzero(&data), E_ZERO_ADDRESS); + Guardian { pubkey: data } + } + + /// Retrieve underlying 20-byte public key. + public fun pubkey(self: &Guardian): Bytes20 { + self.pubkey + } + + /// Retrieve underlying 20-byte public key as `vector`. + public fun as_bytes(self: &Guardian): vector { + bytes20::data(&self.pubkey) + } + + /// Verify that the recovered public key (using `ecrecover`) equals the one + /// that exists for this Guardian with an elliptic curve signature and raw + /// message that was signed. + public fun verify( + self: &Guardian, + signature: GuardianSignature, + message_hash: vector + ): bool { + let sig = guardian_signature::to_rsv(signature); + as_bytes(self) == ecrecover(message_hash, sig) + } + + /// Same as 'ecrecover' in EVM. + fun ecrecover(message: vector, sig: vector): vector { + let pubkey = + ecdsa_k1::decompress_pubkey(&ecdsa_k1::secp256k1_ecrecover(&sig, &message, 0)); + + // `decompress_pubkey` returns 65 bytes. The last 64 bytes are what we + // need to compute the Guardian's public key. + vector::remove(&mut pubkey, 0); + + let hash = hash::keccak256(&pubkey); + let guardian_pubkey = vector::empty(); + let (i, n) = (0, bytes20::length()); + while (i < n) { + vector::push_back( + &mut guardian_pubkey, + vector::pop_back(&mut hash) + ); + i = i + 1; + }; + vector::reverse(&mut guardian_pubkey); + + guardian_pubkey + } + + #[test_only] + public fun destroy(g: Guardian) { + let Guardian { pubkey: _ } = g; + } + + #[test_only] + public fun to_bytes(value: Guardian): vector { + let Guardian { pubkey } = value; + bytes20::to_bytes(pubkey) + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/guardian_set.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/guardian_set.move new file mode 100644 index 0000000000..fd2cc1057d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/guardian_set.move @@ -0,0 +1,193 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a container that keeps track of a list of Guardian +/// public keys and which Guardian set index this list of Guardians represents. +/// Each guardian set is unique and there should be no two sets that have the +/// same Guardian set index (which requirement is handled in `wormhole::state`). +/// +/// If the current Guardian set is not the latest one, its `expiration_time` is +/// configured, which defines how long the past Guardian set can be active. +module wormhole::guardian_set { + use std::vector::{Self}; + use iota::clock::{Self, Clock}; + + use wormhole::guardian::{Self, Guardian}; + + // Needs `set_expiration`. + friend wormhole::state; + + /// Found duplicate public key. + const E_DUPLICATE_GUARDIAN: u64 = 0; + + /// Container for the list of Guardian public keys, its index value and at + /// what point in time the Guardian set is configured to expire. + struct GuardianSet has store { + /// A.K.A. Guardian set index. + index: u32, + + /// List of Guardians. This order should not change. + guardians: vector, + + /// At what point in time the Guardian set is no longer active (in ms). + expiration_timestamp_ms: u64, + } + + /// Create new `GuardianSet`. + public fun new(index: u32, guardians: vector): GuardianSet { + // Ensure that there are no duplicate guardians. + let (i, n) = (0, vector::length(&guardians)); + while (i < n - 1) { + let left = guardian::pubkey(vector::borrow(&guardians, i)); + let j = i + 1; + while (j < n) { + let right = guardian::pubkey(vector::borrow(&guardians, j)); + assert!(left != right, E_DUPLICATE_GUARDIAN); + j = j + 1; + }; + i = i + 1; + }; + + GuardianSet { index, guardians, expiration_timestamp_ms: 0 } + } + + /// Retrieve the Guardian set index. + public fun index(self: &GuardianSet): u32 { + self.index + } + + /// Retrieve the Guardian set index as `u64` (for convenience when used to + /// compare to indices for iterations, which are natively `u64`). + public fun index_as_u64(self: &GuardianSet): u64 { + (self.index as u64) + } + + /// Retrieve list of Guardians. + public fun guardians(self: &GuardianSet): &vector { + &self.guardians + } + + /// Retrieve specific Guardian by index (in the array representing the set). + public fun guardian_at(self: &GuardianSet, index: u64): &Guardian { + vector::borrow(&self.guardians, index) + } + + /// Retrieve when the Guardian set is no longer active. + public fun expiration_timestamp_ms(self: &GuardianSet): u64 { + self.expiration_timestamp_ms + } + + /// Retrieve whether this Guardian set is still active by checking the + /// current time. + public fun is_active(self: &GuardianSet, clock: &Clock): bool { + ( + self.expiration_timestamp_ms == 0 || + self.expiration_timestamp_ms > clock::timestamp_ms(clock) + ) + } + + /// Retrieve how many guardians exist in the Guardian set. + public fun num_guardians(self: &GuardianSet): u64 { + vector::length(&self.guardians) + } + + /// Returns the minimum number of signatures required for a VAA to be valid. + public fun quorum(self: &GuardianSet): u64 { + (num_guardians(self) * 2) / 3 + 1 + } + + /// Configure this Guardian set to expire from some amount of time based on + /// what time it is right now. + /// + /// NOTE: `time_to_live` is in units of seconds while `Clock` uses + /// milliseconds. + public(friend) fun set_expiration( + self: &mut GuardianSet, + seconds_to_live: u32, + the_clock: &Clock + ) { + let ttl_ms = (seconds_to_live as u64) * 1000; + self.expiration_timestamp_ms = clock::timestamp_ms(the_clock) + ttl_ms; + } + + #[test_only] + public fun destroy(set: GuardianSet) { + use wormhole::guardian::{Self}; + + let GuardianSet { + index: _, + guardians, + expiration_timestamp_ms: _ + } = set; + while (!vector::is_empty(&guardians)) { + guardian::destroy(vector::pop_back(&mut guardians)); + }; + + vector::destroy_empty(guardians); + } +} + +#[test_only] +module wormhole::guardian_set_tests { + use std::vector::{Self}; + + use wormhole::guardian::{Self}; + use wormhole::guardian_set::{Self}; + + #[test] + fun test_new() { + let guardians = vector::empty(); + + let pubkeys = vector[ + x"8888888888888888888888888888888888888888", + x"9999999999999999999999999999999999999999", + x"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + x"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + x"cccccccccccccccccccccccccccccccccccccccc", + x"dddddddddddddddddddddddddddddddddddddddd", + x"eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", + x"ffffffffffffffffffffffffffffffffffffffff" + ]; + while (!vector::is_empty(&pubkeys)) { + vector::push_back( + &mut guardians, + guardian::new(vector::pop_back(&mut pubkeys)) + ); + }; + + let set = guardian_set::new(69, guardians); + + // Clean up. + guardian_set::destroy(set); + } + + #[test] + #[expected_failure(abort_code = guardian_set::E_DUPLICATE_GUARDIAN)] + fun test_cannot_new_duplicate_guardian() { + let guardians = vector::empty(); + + let pubkeys = vector[ + x"8888888888888888888888888888888888888888", + x"9999999999999999999999999999999999999999", + x"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + x"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + x"cccccccccccccccccccccccccccccccccccccccc", + x"dddddddddddddddddddddddddddddddddddddddd", + x"eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", + x"ffffffffffffffffffffffffffffffffffffffff", + x"cccccccccccccccccccccccccccccccccccccccc", + ]; + while (!vector::is_empty(&pubkeys)) { + vector::push_back( + &mut guardians, + guardian::new(vector::pop_back(&mut pubkeys)) + ); + }; + + let set = guardian_set::new(69, guardians); + + // Clean up. + guardian_set::destroy(set); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/set.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/set.move new file mode 100644 index 0000000000..21da087083 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/resources/set.move @@ -0,0 +1,88 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type that resembles the set data structure. +/// `Set` leverages `iota::table` to store unique keys of the same type. +/// +/// NOTE: Items added to this data structure cannot be removed. +module wormhole::set { + use iota::table::{Self, Table}; + use iota::tx_context::{TxContext}; + + /// Explicit error if key already exists in `Set`. + const E_KEY_ALREADY_EXISTS: u64 = 0; + /// Explicit error if key does not exist in `Set`. + const E_KEY_NONEXISTENT: u64 = 1; + + /// Empty struct. Used as the value type in mappings to encode a set + struct Empty has store, drop {} + + /// A set containing elements of type `T` with support for membership + /// checking. + struct Set has store { + items: Table + } + + /// Create a new Set. + public fun new(ctx: &mut TxContext): Set { + Set { items: table::new(ctx) } + } + + /// Add a new element to the set. + /// Aborts if the element already exists + public fun add(self: &mut Set, key: T) { + assert!(!contains(self, key), E_KEY_ALREADY_EXISTS); + table::add(&mut self.items, key, Empty {}) + } + + /// Returns true iff `set` contains an entry for `key`. + public fun contains(self: &Set, key: T): bool { + table::contains(&self.items, key) + } + + public fun remove(self: &mut Set, key: T) { + assert!(contains(self, key), E_KEY_NONEXISTENT); + table::remove(&mut self.items, key); + } + + #[test_only] + public fun destroy(set: Set) { + let Set { items } = set; + table::drop(items); + } + +} + +#[test_only] +module wormhole::set_tests { + use iota::tx_context::{Self}; + + use wormhole::set::{Self}; + + #[test] + public fun test_add_and_contains() { + let ctx = &mut tx_context::dummy(); + + let my_set = set::new(ctx); + + let (i, n) = (0, 256); + while (i < n) { + set::add(&mut my_set, i); + i = i + 1; + }; + + // Check that the set has the values just added. + let i = 0; + while (i < n) { + assert!(set::contains(&my_set, i), 0); + i = i + 1; + }; + + // Check that these values that were not added are not in the set. + while (i < 2 * n) { + assert!(!set::contains(&my_set, i), 0); + i = i + 1; + }; + + set::destroy(my_set); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/setup.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/setup.move new file mode 100644 index 0000000000..55eccb3ce0 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/setup.move @@ -0,0 +1,327 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements the mechanism to publish the Wormhole contract and +/// initialize `State` as a shared object. +module wormhole::setup { + use std::vector::{Self}; + use iota::object::{Self, UID}; + use iota::package::{Self, UpgradeCap}; + use iota::transfer::{Self}; + use iota::tx_context::{Self, TxContext}; + + use wormhole::cursor::{Self}; + use wormhole::state::{Self}; + + /// Capability created at `init`, which will be destroyed once + /// `init_and_share_state` is called. This ensures only the deployer can + /// create the shared `State`. + struct DeployerCap has key, store { + id: UID + } + + /// Called automatically when module is first published. Transfers + /// `DeployerCap` to sender. + /// + /// Only `setup::init_and_share_state` requires `DeployerCap`. + fun init(ctx: &mut TxContext) { + let deployer = DeployerCap { id: object::new(ctx) }; + transfer::transfer(deployer, tx_context::sender(ctx)); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(ctx); + + // This will be created and sent to the transaction sender + // automatically when the contract is published. + transfer::public_transfer( + iota::package::test_publish(object::id_from_address(@wormhole), ctx), + tx_context::sender(ctx) + ); + } + + #[allow(lint(share_owned))] + /// Only the owner of the `DeployerCap` can call this method. This + /// method destroys the capability and shares the `State` object. + public fun complete( + deployer: DeployerCap, + upgrade_cap: UpgradeCap, + governance_chain: u16, + governance_contract: vector, + guardian_set_index: u32, + initial_guardians: vector>, + guardian_set_seconds_to_live: u32, + message_fee: u64, + ctx: &mut TxContext + ) { + wormhole::package_utils::assert_package_upgrade_cap( + &upgrade_cap, + package::compatible_policy(), + 1 + ); + + // Destroy deployer cap. + let DeployerCap { id } = deployer; + object::delete(id); + + let guardians = { + let out = vector::empty(); + let cur = cursor::new(initial_guardians); + while (!cursor::is_empty(&cur)) { + vector::push_back( + &mut out, + wormhole::guardian::new(cursor::poke(&mut cur)) + ); + }; + cursor::destroy_empty(cur); + out + }; + + // Share new state. + transfer::public_share_object( + state::new( + upgrade_cap, + governance_chain, + wormhole::external_address::new_nonzero( + wormhole::bytes32::from_bytes(governance_contract) + ), + guardian_set_index, + guardians, + guardian_set_seconds_to_live, + message_fee, + ctx + ) + ); + } +} + +#[test_only] +module wormhole::setup_tests { + use std::option::{Self}; + use std::vector::{Self}; + use iota::package::{Self}; + use iota::object::{Self}; + use iota::test_scenario::{Self}; + + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self}; + use wormhole::guardian::{Self}; + use wormhole::guardian_set::{Self}; + use wormhole::setup::{Self, DeployerCap}; + use wormhole::state::{Self, State}; + use wormhole::wormhole_scenario::{person}; + + #[test] + fun test_init() { + let deployer = person(); + let my_scenario = test_scenario::begin(deployer); + let scenario = &mut my_scenario; + + // Initialize Wormhole smart contract. + setup::init_test_only(test_scenario::ctx(scenario)); + + // Process effects of `init`. + let effects = test_scenario::next_tx(scenario, deployer); + + // We expect two objects to be created: `DeployerCap` and `UpgradeCap`. + assert!(vector::length(&test_scenario::created(&effects)) == 2, 0); + + // We should be able to take the `DeployerCap` from the sender + // of the transaction. + let cap = + test_scenario::take_from_address( + scenario, + deployer + ); + + // The above should succeed, so we will return to `deployer`. + test_scenario::return_to_address(deployer, cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_complete() { + let deployer = person(); + let my_scenario = test_scenario::begin(deployer); + let scenario = &mut my_scenario; + + // Initialize Wormhole smart contract. + setup::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, deployer); + + let governance_chain = 1234; + let governance_contract = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + let guardian_set_index = 0; + let initial_guardians = + vector[ + x"1337133713371337133713371337133713371337", + x"c0dec0dec0dec0dec0dec0dec0dec0dec0dec0de", + x"ba5edba5edba5edba5edba5edba5edba5edba5ed" + ]; + let guardian_set_seconds_to_live = 5678; + let message_fee = 350; + + // Take the `DeployerCap` and move it to `init_and_share_state`. + let deployer_cap = + test_scenario::take_from_address( + scenario, + deployer + ); + let deployer_cap_id = object::id(&deployer_cap); + + // This will be created and sent to the transaction sender automatically + // when the contract is published. This exists in place of grabbing + // it from the sender. + let upgrade_cap = + package::test_publish( + object::id_from_address(@wormhole), + test_scenario::ctx(scenario) + ); + + setup::complete( + deployer_cap, + upgrade_cap, + governance_chain, + governance_contract, + guardian_set_index, + initial_guardians, + guardian_set_seconds_to_live, + message_fee, + test_scenario::ctx(scenario) + ); + + // Process effects. + let effects = test_scenario::next_tx(scenario, deployer); + + // We expect one object to be created: `State`. And it is shared. + let created = test_scenario::created(&effects); + let shared = test_scenario::shared(&effects); + assert!(vector::length(&created) == 1, 0); + assert!(vector::length(&shared) == 1, 0); + assert!( + vector::borrow(&created, 0) == vector::borrow(&shared, 0), + 0 + ); + + // Verify `State`. Ideally we compare structs, but we will check each + // element. + let worm_state = test_scenario::take_shared(scenario); + + assert!(state::governance_chain(&worm_state) == governance_chain, 0); + + let expected_governance_contract = + external_address::new_nonzero( + bytes32::from_bytes(governance_contract) + ); + assert!( + state::governance_contract(&worm_state) == expected_governance_contract, + 0 + ); + + assert!(state::guardian_set_index(&worm_state) == 0, 0); + assert!( + state::guardian_set_seconds_to_live(&worm_state) == guardian_set_seconds_to_live, + 0 + ); + + let guardians = + guardian_set::guardians( + state::guardian_set_at(&worm_state, 0) + ); + let num_guardians = vector::length(guardians); + assert!(num_guardians == vector::length(&initial_guardians), 0); + + let i = 0; + while (i < num_guardians) { + let left = guardian::as_bytes(vector::borrow(guardians, i)); + let right = *vector::borrow(&initial_guardians, i); + assert!(left == right, 0); + i = i + 1; + }; + + assert!(state::message_fee(&worm_state) == message_fee, 0); + + // Clean up. + test_scenario::return_shared(worm_state); + + // We expect `DeployerCap` to be destroyed. There are other + // objects deleted, but we only care about the deployer cap for this + // test. + let deleted = cursor::new(test_scenario::deleted(&effects)); + let found = option::none(); + while (!cursor::is_empty(&deleted)) { + let id = cursor::poke(&mut deleted); + if (id == deployer_cap_id) { + found = option::some(id); + } + }; + cursor::destroy_empty(deleted); + + // If we found the deployer cap, `found` will have the ID. + assert!(!option::is_none(&found), 0); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure( + abort_code = wormhole::package_utils::E_INVALID_UPGRADE_CAP + )] + fun test_cannot_complete_invalid_upgrade_cap() { + let deployer = person(); + let my_scenario = test_scenario::begin(deployer); + let scenario = &mut my_scenario; + + // Initialize Wormhole smart contract. + setup::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, deployer); + + let governance_chain = 1234; + let governance_contract = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + let guardian_set_index = 0; + let initial_guardians = + vector[x"1337133713371337133713371337133713371337"]; + let guardian_set_seconds_to_live = 5678; + let message_fee = 350; + + // Take the `DeployerCap` and move it to `init_and_share_state`. + let deployer_cap = + test_scenario::take_from_address( + scenario, + deployer + ); + + // This will be created and sent to the transaction sender automatically + // when the contract is published. This exists in place of grabbing + // it from the sender. + let upgrade_cap = + package::test_publish( + object::id_from_address(@0xbadc0de), + test_scenario::ctx(scenario) + ); + + setup::complete( + deployer_cap, + upgrade_cap, + governance_chain, + governance_contract, + guardian_set_index, + initial_guardians, + guardian_set_seconds_to_live, + message_fee, + test_scenario::ctx(scenario) + ); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/state.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/state.move new file mode 100644 index 0000000000..c06bd47db8 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/state.move @@ -0,0 +1,468 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements the global state variables for Wormhole as a shared +/// object. The `State` object is used to perform anything that requires access +/// to data that defines the Wormhole contract. Examples of which are publishing +/// Wormhole messages (requires depositing a message fee), verifying `VAA` by +/// checking signatures versus an existing Guardian set, and generating new +/// emitters for Wormhole integrators. +module wormhole::state { + use std::vector::{Self}; + use iota::balance::{Balance}; + use iota::clock::{Clock}; + use iota::object::{Self, ID, UID}; + use iota::package::{UpgradeCap, UpgradeReceipt, UpgradeTicket}; + use iota::iota::{IOTA}; + use iota::table::{Self, Table}; + use iota::tx_context::{TxContext}; + + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::consumed_vaas::{Self, ConsumedVAAs}; + use wormhole::external_address::{ExternalAddress}; + use wormhole::fee_collector::{Self, FeeCollector}; + use wormhole::guardian::{Guardian}; + use wormhole::guardian_set::{Self, GuardianSet}; + use wormhole::package_utils::{Self}; + use wormhole::version_control::{Self}; + + friend wormhole::emitter; + friend wormhole::governance_message; + friend wormhole::migrate; + friend wormhole::publish_message; + friend wormhole::set_fee; + friend wormhole::setup; + friend wormhole::transfer_fee; + friend wormhole::update_guardian_set; + friend wormhole::upgrade_contract; + friend wormhole::vaa; + + /// Cannot initialize state with zero guardians. + const E_ZERO_GUARDIANS: u64 = 0; + /// Build digest does not agree with current implementation. + const E_INVALID_BUILD_DIGEST: u64 = 1; + + /// Iota's chain ID is hard-coded to one value. + const CHAIN_ID: u16 = 50118; + + /// Capability reflecting that the current build version is used to invoke + /// state methods. + struct LatestOnly has drop {} + + /// Container for all state variables for Wormhole. + struct State has key, store { + id: UID, + + /// Governance chain ID. + governance_chain: u16, + + /// Governance contract address. + governance_contract: ExternalAddress, + + /// Current active guardian set index. + guardian_set_index: u32, + + /// All guardian sets (including expired ones). + guardian_sets: Table, + + /// Period for which a guardian set stays active after it has been + /// replaced. + /// + /// NOTE: `Clock` timestamp is in units of ms while this value is in + /// terms of seconds. See `guardian_set` module for more info. + guardian_set_seconds_to_live: u32, + + /// Consumed VAA hashes to protect against replay. VAAs relevant to + /// Wormhole are just governance VAAs. + consumed_vaas: ConsumedVAAs, + + /// Wormhole fee collector. + fee_collector: FeeCollector, + + /// Upgrade capability. + upgrade_cap: UpgradeCap + } + + /// Create new `State`. This is only executed using the `setup` module. + public(friend) fun new( + upgrade_cap: UpgradeCap, + governance_chain: u16, + governance_contract: ExternalAddress, + guardian_set_index: u32, + initial_guardians: vector, + guardian_set_seconds_to_live: u32, + message_fee: u64, + ctx: &mut TxContext + ): State { + // We need at least one guardian. + assert!(vector::length(&initial_guardians) > 0, E_ZERO_GUARDIANS); + + let state = State { + id: object::new(ctx), + governance_chain, + governance_contract, + guardian_set_index, + guardian_sets: table::new(ctx), + guardian_set_seconds_to_live, + consumed_vaas: consumed_vaas::new(ctx), + fee_collector: fee_collector::new(message_fee), + upgrade_cap + }; + + // Set first version and initialize package info. This will be used for + // emitting information of successful migrations. + let upgrade_cap = &state.upgrade_cap; + package_utils::init_package_info( + &mut state.id, + version_control::current_version(), + upgrade_cap + ); + + // Store the initial guardian set. + add_new_guardian_set( + &assert_latest_only(&state), + &mut state, + guardian_set::new(guardian_set_index, initial_guardians) + ); + + state + } + + //////////////////////////////////////////////////////////////////////////// + // + // Simple Getters + // + // These methods do not require `LatestOnly` for access. Anyone is free to + // access these values. + // + //////////////////////////////////////////////////////////////////////////// + + /// Convenience method to get hard-coded Wormhole chain ID (recognized by + /// the Wormhole network). + public fun chain_id(): u16 { + CHAIN_ID + } + + /// Retrieve governance module name. + public fun governance_module(): Bytes32 { + // A.K.A. "Core". + bytes32::new( + x"00000000000000000000000000000000000000000000000000000000436f7265" + ) + } + + /// Retrieve governance chain ID, which is governance's emitter chain ID. + public fun governance_chain(self: &State): u16 { + self.governance_chain + } + + /// Retrieve governance emitter address. + public fun governance_contract(self: &State): ExternalAddress { + self.governance_contract + } + + /// Retrieve current Guardian set index. This value is important for + /// verifying VAA signatures and especially important for governance VAAs. + public fun guardian_set_index(self: &State): u32 { + self.guardian_set_index + } + + /// Retrieve how long after a Guardian set can live for in terms of Iota + /// timestamp (in seconds). + public fun guardian_set_seconds_to_live(self: &State): u32 { + self.guardian_set_seconds_to_live + } + + /// Retrieve a particular Guardian set by its Guardian set index. This + /// method is used when verifying a VAA. + /// + /// See `wormhole::vaa` for more info. + public fun guardian_set_at( + self: &State, + index: u32 + ): &GuardianSet { + table::borrow(&self.guardian_sets, index) + } + + /// Retrieve current fee to send Wormhole message. + public fun message_fee(self: &State): u64 { + fee_collector::fee_amount(&self.fee_collector) + } + + #[test_only] + public fun fees_collected(self: &State): u64 { + fee_collector::balance_value(&self.fee_collector) + } + + #[test_only] + public fun cache_latest_only_test_only(self: &State): LatestOnly { + assert_latest_only(self) + } + + #[test_only] + public fun deposit_fee_test_only(self: &mut State, fee: Balance) { + deposit_fee(&assert_latest_only(self), self, fee) + } + + #[test_only] + public fun migrate_version_test_only( + self: &mut State, + old_version: Old, + new_version: New + ) { + package_utils::update_version_type_test_only( + &mut self.id, + old_version, + new_version + ); + } + + #[test_only] + public fun test_upgrade(self: &mut State) { + let test_digest = bytes32::from_bytes(b"new build"); + let ticket = authorize_upgrade(self, test_digest); + let receipt = iota::package::test_upgrade(ticket); + commit_upgrade(self, receipt); + } + + #[test_only] + public fun reverse_migrate_version(self: &mut State) { + package_utils::update_version_type_test_only( + &mut self.id, + version_control::current_version(), + version_control::previous_version() + ); + } + + //////////////////////////////////////////////////////////////////////////// + // + // Privileged `State` Access + // + // This section of methods require a `LatestOnly`, which can only be created + // within the Wormhole package. This capability allows special access to + // the `State` object. + // + // NOTE: A lot of these methods are still marked as `(friend)` as a safety + // precaution. When a package is upgraded, friend modifiers can be + // removed. + // + //////////////////////////////////////////////////////////////////////////// + + /// Obtain a capability to interact with `State` methods. This method checks + /// that we are running the current build. + /// + /// NOTE: This method allows caching the current version check so we avoid + /// multiple checks to dynamic fields. + public(friend) fun assert_latest_only(self: &State): LatestOnly { + package_utils::assert_version( + &self.id, + version_control::current_version() + ); + + LatestOnly {} + } + + /// Deposit fee when sending Wormhole message. This method does not + /// necessarily have to be a `friend` to `wormhole::publish_message`. But + /// we also do not want an integrator to mistakenly deposit fees outside + /// of calling `publish_message`. + /// + /// See `wormhole::publish_message` for more info. + public(friend) fun deposit_fee( + _: &LatestOnly, + self: &mut State, + fee: Balance + ) { + fee_collector::deposit_balance(&mut self.fee_collector, fee); + } + + /// Withdraw collected fees when governance action to transfer fees to a + /// particular recipient. + /// + /// See `wormhole::transfer_fee` for more info. + public(friend) fun withdraw_fee( + _: &LatestOnly, + self: &mut State, + amount: u64 + ): Balance { + fee_collector::withdraw_balance(&mut self.fee_collector, amount) + } + + /// Store `VAA` hash as a way to claim a VAA. This method prevents a VAA + /// from being replayed. For Wormhole, the only VAAs that it cares about + /// being replayed are its governance actions. + public(friend) fun borrow_mut_consumed_vaas( + _: &LatestOnly, + self: &mut State + ): &mut ConsumedVAAs { + borrow_mut_consumed_vaas_unchecked(self) + } + + /// Store `VAA` hash as a way to claim a VAA. This method prevents a VAA + /// from being replayed. For Wormhole, the only VAAs that it cares about + /// being replayed are its governance actions. + /// + /// NOTE: This method does not require `LatestOnly`. Only methods in the + /// `upgrade_contract` module requires this to be unprotected to prevent + /// a corrupted upgraded contract from bricking upgradability. + public(friend) fun borrow_mut_consumed_vaas_unchecked( + self: &mut State + ): &mut ConsumedVAAs { + &mut self.consumed_vaas + } + + /// When a new guardian set is added to `State`, part of the process + /// involves setting the last known Guardian set's expiration time based + /// on how long a Guardian set can live for. + /// + /// See `guardian_set_epochs_to_live` for the parameter that determines how + /// long a Guardian set can live for. + /// + /// See `wormhole::update_guardian_set` for more info. + public(friend) fun expire_guardian_set( + _: &LatestOnly, + self: &mut State, + the_clock: &Clock + ) { + guardian_set::set_expiration( + table::borrow_mut(&mut self.guardian_sets, self.guardian_set_index), + self.guardian_set_seconds_to_live, + the_clock + ); + } + + /// Add the latest Guardian set from the governance action to update the + /// current guardian set. + /// + /// See `wormhole::update_guardian_set` for more info. + public(friend) fun add_new_guardian_set( + _: &LatestOnly, + self: &mut State, + new_guardian_set: GuardianSet + ) { + self.guardian_set_index = guardian_set::index(&new_guardian_set); + table::add( + &mut self.guardian_sets, + self.guardian_set_index, + new_guardian_set + ); + } + + /// Modify the cost to send a Wormhole message via governance. + /// + /// See `wormhole::set_fee` for more info. + public(friend) fun set_message_fee( + _: &LatestOnly, + self: &mut State, + amount: u64 + ) { + fee_collector::change_fee(&mut self.fee_collector, amount); + } + + public(friend) fun current_package(_: &LatestOnly, self: &State): ID { + package_utils::current_package(&self.id) + } + + //////////////////////////////////////////////////////////////////////////// + // + // Upgradability + // + // A special space that controls upgrade logic. These methods are invoked + // via the `upgrade_contract` module. + // + // Also in this section is managing contract migrations, which uses the + // `migrate` module to officially roll state access to the latest build. + // Only those methods that require `LatestOnly` will be affected by an + // upgrade. + // + //////////////////////////////////////////////////////////////////////////// + + /// Issue an `UpgradeTicket` for the upgrade. + /// + /// NOTE: The Iota VM performs a check that this method is executed from the + /// latest published package. If someone were to try to execute this using + /// a stale build, the transaction will revert with `PackageUpgradeError`, + /// specifically `PackageIDDoesNotMatch`. + public(friend) fun authorize_upgrade( + self: &mut State, + package_digest: Bytes32 + ): UpgradeTicket { + let cap = &mut self.upgrade_cap; + package_utils::authorize_upgrade(&mut self.id, cap, package_digest) + } + + /// Finalize the upgrade that ran to produce the given `receipt`. + /// + /// NOTE: The Iota VM performs a check that this method is executed from the + /// latest published package. If someone were to try to execute this using + /// a stale build, the transaction will revert with `PackageUpgradeError`, + /// specifically `PackageIDDoesNotMatch`. + public(friend) fun commit_upgrade( + self: &mut State, + receipt: UpgradeReceipt + ): (ID, ID) { + let cap = &mut self.upgrade_cap; + package_utils::commit_upgrade(&mut self.id, cap, receipt) + } + + /// Method executed by the `migrate` module to roll access from one package + /// to another. This method will be called from the upgraded package. + public(friend) fun migrate_version(self: &mut State) { + package_utils::migrate_version( + &mut self.id, + version_control::previous_version(), + version_control::current_version() + ); + } + + /// As a part of the migration, we verify that the upgrade contract VAA's + /// encoded package digest used in `migrate` equals the one used to conduct + /// the upgrade. + public(friend) fun assert_authorized_digest( + _: &LatestOnly, + self: &State, + digest: Bytes32 + ) { + let authorized = package_utils::authorized_digest(&self.id); + assert!(digest == authorized, E_INVALID_BUILD_DIGEST); + } + + //////////////////////////////////////////////////////////////////////////// + // + // Special State Interaction via Migrate + // + // A VERY special space that manipulates `State` via calling `migrate`. + // + // PLEASE KEEP ANY METHODS HERE AS FRIENDS. We want the ability to remove + // these for future builds. + // + //////////////////////////////////////////////////////////////////////////// + + /// This method is used to make modifications to `State` when `migrate` is + /// called. This method name should change reflecting which version this + /// contract is migrating to. + /// + /// NOTE: Please keep this method as public(friend) because we never want + /// to expose this method as a public method. + public(friend) fun migrate__v__0_2_0(_self: &mut State) { + // Intentionally do nothing. + } + + #[test_only] + /// Bloody hack. + /// + /// This method is used to set up tests where we migrate to a new version, + /// which is meant to test that modules protected by version control will + /// break. + public fun reverse_migrate__v__dummy(_self: &mut State) { + // Intentionally do nothing. + } + + //////////////////////////////////////////////////////////////////////////// + // + // Deprecated + // + // Dumping grounds for old structs and methods. These things should not + // be used in future builds. + // + //////////////////////////////////////////////////////////////////////////// +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/test/wormhole_scenario.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/test/wormhole_scenario.move new file mode 100644 index 0000000000..cb4ba70403 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/test/wormhole_scenario.move @@ -0,0 +1,224 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +/// This module implements ways to initialize Wormhole in a test scenario. This +/// module includes a default method (`set_up_wormhole`) with only one of the +/// devnet (Tilt) Guardians. The private key for this Guardian is known (see the +/// main Wormhole repository at https://github.com/wormhole-foundation/wormhole +/// for the key), which allows an integrator to generate his own VAAs and +/// validate them with this test-only Wormhole instance. +module wormhole::wormhole_scenario { + use std::vector::{Self}; + use iota::clock::{Self, Clock}; + use iota::package::{UpgradeCap}; + use iota::test_scenario::{Self, Scenario}; + + use wormhole::emitter::{EmitterCap}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + use wormhole::setup::{Self, DeployerCap}; + use wormhole::state::{Self, State}; + use wormhole::vaa::{Self, VAA}; + + const DEPLOYER: address = @0xDEADBEEF; + const WALLET_1: address = @0xB0B1; + const WALLET_2: address = @0xB0B2; + const WALLET_3: address = @0xB0B3; + const VAA_VERIFIER: address = @0xD00D; + const EMITTER_MAKER: address = @0xFEED; + + /// Set up Wormhole with any guardian pubkeys. For most testing purposes, + /// please use `set_up_wormhole` which only uses one guardian. + /// + /// NOTE: This also creates `Clock` for testing. + public fun set_up_wormhole_with_guardians( + scenario: &mut Scenario, + message_fee: u64, + initial_guardians: vector>, + ) { + // Process effects prior. `init_test_only` will be executed as the + // Wormhole contract deployer. + test_scenario::next_tx(scenario, DEPLOYER); + + // `init` Wormhole contract as if it were published. + wormhole::setup::init_test_only(test_scenario::ctx(scenario)); + + // `init_and_share_state` will also be executed as the Wormhole deployer + // to destroy the `DeployerCap` to create a sharable `State`. + test_scenario::next_tx(scenario, DEPLOYER); + + // Parameters for Wormhole's `State` are common in the Wormhole testing + // environment aside from the `guardian_set_epochs_to_live`, which at + // the moment needs to be discussed on how to configure. As of now, + // there is no clock with unix timestamp to expire guardian sets in + // terms of human-interpretable time. + { + // This will be created and sent to the transaction sender + // automatically when the contract is published. This exists in + // place of grabbing it from the sender. + let upgrade_cap = + test_scenario::take_from_sender(scenario); + + let governance_chain = 1; + let governance_contract = + x"0000000000000000000000000000000000000000000000000000000000000004"; + let guardian_set_index = 0; + let guardian_set_seconds_to_live = 420; + + // Share `State`. + setup::complete( + test_scenario::take_from_address( + scenario, DEPLOYER + ), + upgrade_cap, + governance_chain, + governance_contract, + guardian_set_index, + initial_guardians, + guardian_set_seconds_to_live, + message_fee, + test_scenario::ctx(scenario) + ); + }; + + // Done. + } + + /// Set up Wormhole with only the first devnet guardian. + public fun set_up_wormhole(scenario: &mut Scenario, message_fee: u64) { + let initial_guardians = vector::empty(); + vector::push_back( + &mut initial_guardians, + *vector::borrow(&guardians(), 0) + ); + + set_up_wormhole_with_guardians(scenario, message_fee, initial_guardians) + } + + /// Perform an upgrade (which just upticks the current version of what the + /// `State` believes is true). + public fun upgrade_wormhole(scenario: &mut Scenario) { + // Clean up from activity prior. + test_scenario::next_tx(scenario, person()); + + let worm_state = take_state(scenario); + state::test_upgrade(&mut worm_state); + + // Clean up. + return_state(worm_state); + } + + /// Address of wallet that published Wormhole contract. + public fun deployer(): address { + DEPLOYER + } + + public fun person(): address { + WALLET_1 + } + + public fun two_people(): (address, address) { + (WALLET_1, WALLET_2) + } + + public fun three_people(): (address, address, address) { + (WALLET_1, WALLET_2, WALLET_3) + } + + /// All guardians that exist in devnet (Tilt) environment. + public fun guardians(): vector> { + vector[ + x"befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe", + x"88d7d8b32a9105d228100e72dffe2fae0705d31c", + x"58076f561cc62a47087b567c86f986426dfcd000", + x"bd6e9833490f8fa87c733a183cd076a6cbd29074", + x"b853fcf0a5c78c1b56d15fce7a154e6ebe9ed7a2", + x"af3503dbd2e37518ab04d7ce78b630f98b15b78a", + x"785632dea5609064803b1c8ea8bb2c77a6004bd1", + x"09a281a698c0f5ba31f158585b41f4f33659e54d", + x"3178443ab76a60e21690dbfb17f7f59f09ae3ea1", + x"647ec26ae49b14060660504f4da1c2059e1c5ab6", + x"810ac3d8e1258bd2f004a94ca0cd4c68fc1c0611", + x"80610e96d645b12f47ae5cf4546b18538739e90f", + x"2edb0d8530e31a218e72b9480202acbaeb06178d", + x"a78858e5e5c4705cdd4b668ffe3be5bae4867c9d", + x"5efe3a05efc62d60e1d19faeb56a80223cdd3472", + x"d791b7d32c05abb1cc00b6381fa0c4928f0c56fc", + x"14bc029b8809069093d712a3fd4dfab31963597e", + x"246ab29fc6ebedf2d392a51ab2dc5c59d0902a03", + x"132a84dfd920b35a3d0ba5f7a0635df298f9033e", + ] + } + + public fun take_state(scenario: &Scenario): State { + test_scenario::take_shared(scenario) + } + + public fun return_state(wormhole_state: State) { + test_scenario::return_shared(wormhole_state); + } + + public fun parse_and_verify_vaa( + scenario: &mut Scenario, + vaa_buf: vector + ): VAA { + test_scenario::next_tx(scenario, VAA_VERIFIER); + + let the_clock = take_clock(scenario); + let worm_state = take_state(scenario); + + let out = + vaa::parse_and_verify( + &worm_state, + vaa_buf, + &the_clock + ); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + out + } + + public fun verify_governance_vaa( + scenario: &mut Scenario, + verified_vaa: VAA, + ticket: DecreeTicket + ): DecreeReceipt { + test_scenario::next_tx(scenario, VAA_VERIFIER); + + let worm_state = take_state(scenario); + + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + return_state(worm_state); + + receipt + } + + public fun new_emitter( + scenario: &mut Scenario + ): EmitterCap { + test_scenario::next_tx(scenario, EMITTER_MAKER); + + let worm_state = take_state(scenario); + + let emitter = + wormhole::emitter::new(&worm_state, test_scenario::ctx(scenario)); + + // Clean up. + return_state(worm_state); + + emitter + } + + public fun take_clock(scenario: &mut Scenario): Clock { + clock::create_for_testing(test_scenario::ctx(scenario)) + } + + public fun return_clock(the_clock: Clock) { + clock::destroy_for_testing(the_clock) + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/utils/bytes.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/utils/bytes.move new file mode 100644 index 0000000000..0d181f6775 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/utils/bytes.move @@ -0,0 +1,232 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a library that serializes and deserializes specific +/// types into a buffer (i.e. `vector`). For serialization, the first +/// argument will be of `&mut vector`. For deserialization, the first +/// argument will be of `&mut Cursor` (see `wormhole::cursor` for more +/// details). +module wormhole::bytes { + use std::vector::{Self}; + use std::bcs::{Self}; + use wormhole::cursor::{Self, Cursor}; + + public fun push_u8(buf: &mut vector, v: u8) { + vector::push_back(buf, v); + } + + public fun push_u16_be(buf: &mut vector, value: u16) { + push_reverse(buf, value); + } + + public fun push_u32_be(buf: &mut vector, value: u32) { + push_reverse(buf, value); + } + + public fun push_u64_be(buf: &mut vector, value: u64) { + push_reverse(buf, value); + } + + public fun push_u128_be(buf: &mut vector, value: u128) { + push_reverse(buf, value); + } + + public fun push_u256_be(buf: &mut vector, value: u256) { + push_reverse(buf, value); + } + + public fun take_u8(cur: &mut Cursor): u8 { + cursor::poke(cur) + } + + public fun take_u16_be(cur: &mut Cursor): u16 { + let out = 0; + let i = 0; + while (i < 2) { + out = (out << 8) + (cursor::poke(cur) as u16); + i = i + 1; + }; + out + } + + public fun take_u32_be(cur: &mut Cursor): u32 { + let out = 0; + let i = 0; + while (i < 4) { + out = (out << 8) + (cursor::poke(cur) as u32); + i = i + 1; + }; + out + } + + public fun take_u64_be(cur: &mut Cursor): u64 { + let out = 0; + let i = 0; + while (i < 8) { + out = (out << 8) + (cursor::poke(cur) as u64); + i = i + 1; + }; + out + } + + public fun take_u128_be(cur: &mut Cursor): u128 { + let out = 0; + let i = 0; + while (i < 16) { + out = (out << 8) + (cursor::poke(cur) as u128); + i = i + 1; + }; + out + } + + public fun take_u256_be(cur: &mut Cursor): u256 { + let out = 0; + let i = 0; + while (i < 32) { + out = (out << 8) + (cursor::poke(cur) as u256); + i = i + 1; + }; + out + } + + public fun take_bytes(cur: &mut Cursor, num_bytes: u64): vector { + let out = vector::empty(); + let i = 0; + while (i < num_bytes) { + vector::push_back(&mut out, cursor::poke(cur)); + i = i + 1; + }; + out + } + + fun push_reverse(buf: &mut vector, v: T) { + let data = bcs::to_bytes(&v); + vector::reverse(&mut data); + vector::append(buf, data); + } +} + +#[test_only] +module wormhole::bytes_tests { + use std::vector::{Self}; + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + + #[test] + fun test_push_u8(){ + let u = 0x12; + let s = vector::empty(); + bytes::push_u8(&mut s, u); + let cur = cursor::new(s); + let p = bytes::take_u8(&mut cur); + cursor::destroy_empty(cur); + assert!(p==u, 0); + } + + #[test] + fun test_push_u16_be(){ + let u = 0x1234; + let s = vector::empty(); + bytes::push_u16_be(&mut s, u); + let cur = cursor::new(s); + let p = bytes::take_u16_be(&mut cur); + cursor::destroy_empty(cur); + assert!(p==u, 0); + } + + #[test] + fun test_push_u32_be(){ + let u = 0x12345678; + let s = vector::empty(); + bytes::push_u32_be(&mut s, u); + let cur = cursor::new(s); + let p = bytes::take_u32_be(&mut cur); + cursor::destroy_empty(cur); + assert!(p==u, 0); + } + + #[test] + fun test_push_u64_be(){ + let u = 0x1234567812345678; + let s = vector::empty(); + bytes::push_u64_be(&mut s, u); + let cur = cursor::new(s); + let p = bytes::take_u64_be(&mut cur); + cursor::destroy_empty(cur); + assert!(p==u, 0); + } + + #[test] + fun test_push_u128_be(){ + let u = 0x12345678123456781234567812345678; + let s = vector::empty(); + bytes::push_u128_be(&mut s, u); + let cur = cursor::new(s); + let p = bytes::take_u128_be(&mut cur); + cursor::destroy_empty(cur); + assert!(p==u, 0); + } + + #[test] + fun test_push_u256_be(){ + let u = + 0x4738691759099793746170047375612500000000000000000000000000009876; + let s = vector::empty(); + bytes::push_u256_be(&mut s, u); + assert!( + s == x"4738691759099793746170047375612500000000000000000000000000009876", + 0 + ); + } + + #[test] + fun test_take_u8() { + let cursor = cursor::new(x"99"); + let byte = bytes::take_u8(&mut cursor); + assert!(byte==0x99, 0); + cursor::destroy_empty(cursor); + } + + #[test] + fun test_take_u16_be() { + let cursor = cursor::new(x"9987"); + let u = bytes::take_u16_be(&mut cursor); + assert!(u == 0x9987, 0); + cursor::destroy_empty(cursor); + } + + #[test] + fun test_take_u32_be() { + let cursor = cursor::new(x"99876543"); + let u = bytes::take_u32_be(&mut cursor); + assert!(u == 0x99876543, 0); + cursor::destroy_empty(cursor); + } + + #[test] + fun test_take_u64_be() { + let cursor = cursor::new(x"1300000025000001"); + let u = bytes::take_u64_be(&mut cursor); + assert!(u == 0x1300000025000001, 0); + cursor::destroy_empty(cursor); + } + + #[test] + fun test_take_u128_be() { + let cursor = cursor::new(x"130209AB2500FA0113CD00AE25000001"); + let u = bytes::take_u128_be(&mut cursor); + assert!(u == 0x130209AB2500FA0113CD00AE25000001, 0); + cursor::destroy_empty(cursor); + } + + #[test] + fun test_to_bytes() { + let cursor = cursor::new(b"hello world"); + let hello = bytes::take_bytes(&mut cursor, 5); + bytes::take_u8(&mut cursor); + let world = bytes::take_bytes(&mut cursor, 5); + assert!(hello == b"hello", 0); + assert!(world == b"world", 0); + cursor::destroy_empty(cursor); + } + +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/utils/cursor.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/utils/cursor.move new file mode 100644 index 0000000000..73a96ebea0 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/utils/cursor.move @@ -0,0 +1,60 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type that allows consuming a vector +/// incrementally for parsing operations. It has no drop ability, and the only +/// way to deallocate it is by calling the `destroy_empty` method, which will +/// fail if the whole input hasn't been consumed. +/// +/// This setup statically guarantees that the parsing methods consume the full +/// input. +module wormhole::cursor { + use std::vector::{Self}; + + /// Container for the underlying `vector` data to be consumed. + struct Cursor { + data: vector, + } + + /// Initialises a cursor from a vector. + public fun new(data: vector): Cursor { + // reverse the array so we have access to the first element easily + vector::reverse(&mut data); + Cursor { data } + } + + /// Retrieve underlying data. + public fun data(self: &Cursor): &vector { + &self.data + } + + /// Check whether the underlying data is empty. This method is useful for + /// iterating over a `Cursor` to exhaust its contents. + public fun is_empty(self: &Cursor): bool { + vector::is_empty(&self.data) + } + + /// Destroys an empty cursor. This method aborts if the cursor is not empty. + public fun destroy_empty(cursor: Cursor) { + let Cursor { data } = cursor; + vector::destroy_empty(data); + } + + /// Consumes the rest of the cursor (thus destroying it) and returns the + /// remaining bytes. + /// + /// NOTE: Only use this function if you intend to consume the rest of the + /// bytes. Since the result is a vector, which can be dropped, it is not + /// possible to statically guarantee that the rest will be used. + public fun take_rest(cursor: Cursor): vector { + let Cursor { data } = cursor; + // Because the data was reversed in initialization, we need to reverse + // again so it is in the same order as the original input. + vector::reverse(&mut data); + data + } + + /// Retrieve the first element of the cursor and advances it. + public fun poke(self: &mut Cursor): T { + vector::pop_back(&mut self.data) + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/utils/package_utils.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/utils/package_utils.move new file mode 100644 index 0000000000..5c0e47c72e --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/utils/package_utils.move @@ -0,0 +1,422 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements utilities that supplement those methods implemented +/// in `iota::package`. +module wormhole::package_utils { + use std::type_name::{Self, TypeName}; + use iota::dynamic_field::{Self as field}; + use iota::object::{Self, ID, UID}; + use iota::package::{Self, UpgradeCap, UpgradeTicket, UpgradeReceipt}; + + use wormhole::bytes32::{Self, Bytes32}; + + /// `UpgradeCap` is not from the same package as `T`. + const E_INVALID_UPGRADE_CAP: u64 = 0; + /// Build is not current. + const E_NOT_CURRENT_VERSION: u64 = 1; + /// Old version to update from is wrong. + const E_INCORRECT_OLD_VERSION: u64 = 2; + /// Old and new are the same version. + const E_SAME_VERSION: u64 = 3; + /// Version types must come from this module. + const E_TYPE_NOT_ALLOWED: u64 = 4; + + /// Key for version dynamic fields. + struct CurrentVersion has store, drop, copy {} + + /// Key for dynamic field reflecting current package info. Its value is + /// `PackageInfo`. + struct CurrentPackage has store, drop, copy {} + struct PendingPackage has store, drop, copy {} + + struct PackageInfo has store, drop, copy { + package: ID, + digest: Bytes32 + } + + /// Retrieve current package ID, which should be the only one that anyone is + /// allowed to interact with. + public fun current_package(id: &UID): ID { + let info: &PackageInfo = field::borrow(id, CurrentPackage {}); + info.package + } + + /// Retrieve the build digest reflecting the current build. + public fun current_digest(id: &UID): Bytes32 { + let info: &PackageInfo = field::borrow(id, CurrentPackage {}); + info.digest + } + + /// Retrieve the upgraded package ID, which was taken from `UpgradeCap` + /// during `commit_upgrade`. + public fun committed_package(id: &UID): ID { + let info: &PackageInfo = field::borrow(id, PendingPackage {}); + info.package + } + + /// Retrieve the build digest of the latest upgrade, which was the same + /// digest used when `authorize_upgrade` is called. + public fun authorized_digest(id: &UID): Bytes32 { + let info: &PackageInfo = field::borrow(id, PendingPackage {}); + info.digest + } + + /// Convenience method that can be used with any package that requires + /// `UpgradeCap` to have certain preconditions before it is considered + /// belonging to `T` object's package. + public fun assert_package_upgrade_cap( + cap: &UpgradeCap, + expected_policy: u8, + expected_version: u64 + ) { + let expected_package = + iota::address::from_bytes( + iota::hex::decode( + std::ascii::into_bytes( + std::type_name::get_address( + &std::type_name::get() + ) + ) + ) + ); + let cap_package = + object::id_to_address(&package::upgrade_package(cap)); + assert!( + ( + cap_package == expected_package && + package::upgrade_policy(cap) == expected_policy && + package::version(cap) == expected_version + ), + E_INVALID_UPGRADE_CAP + ); + } + + /// Assert that the version type passed into this method is what exists + /// as the current version. + public fun assert_version( + id: &UID, + _version: Version + ) { + assert!( + field::exists_with_type( + id, + CurrentVersion {} + ), + E_NOT_CURRENT_VERSION + ) + } + + // Retrieve the `TypeName` of a given version. + public fun type_of_version(_version: Version): TypeName { + type_name::get() + } + + /// Initialize package info and set the initial version. This should be done + /// when a contract's state/storage shared object is created. + public fun init_package_info( + id: &mut UID, + version: InitialVersion, + upgrade_cap: &UpgradeCap + ) { + let package = package::upgrade_package(upgrade_cap); + field::add( + id, + CurrentPackage {}, + PackageInfo { package, digest: bytes32::default() } + ); + + // Set placeholders for pending package. We don't ever plan on removing + // this field. + field::add( + id, + PendingPackage {}, + PackageInfo { package, digest: bytes32::default() } + ); + + // Set the initial version. + field::add(id, CurrentVersion {}, version); + } + + /// Perform the version switchover and copy package info from pending to + /// current. This method should be executed after an upgrade (via a migrate + /// method) from the upgraded package. + /// + /// NOTE: This method can only be called once with the same version type + /// arguments. + public fun migrate_version< + Old: store + drop, + New: store + drop + >( + id: &mut UID, + old_version: Old, + new_version: New + ) { + update_version_type(id, old_version, new_version); + + update_package_info_from_pending(id); + } + + /// Helper for `iota::package::authorize_upgrade` to modify pending package + /// info by updating its digest. + /// + /// NOTE: This digest will be copied over when `migrate_version` is called. + public fun authorize_upgrade( + id: &mut UID, + upgrade_cap: &mut UpgradeCap, + package_digest: Bytes32 + ): UpgradeTicket { + let policy = package::upgrade_policy(upgrade_cap); + + // Manage saving the current digest. + set_authorized_digest(id, package_digest); + + // Finally authorize upgrade. + package::authorize_upgrade( + upgrade_cap, + policy, + bytes32::to_bytes(package_digest), + ) + } + + /// Helper for `iota::package::commit_upgrade` to modify pending package info + /// by updating its package ID with from what exists in the `UpgradeCap`. + /// This method returns the last package and the upgraded package IDs. + /// + /// NOTE: This package ID (second return value) will be copied over when + /// `migrate_version` is called. + public fun commit_upgrade( + id: &mut UID, + upgrade_cap: &mut UpgradeCap, + receipt: UpgradeReceipt + ): (ID, ID) { + // Uptick the upgrade cap version number using this receipt. + package::commit_upgrade(upgrade_cap, receipt); + + // Take the last pending package and replace it with the one now in + // the upgrade cap. + let previous_package = committed_package(id); + set_commited_package(id, upgrade_cap); + + // Return the package IDs. + (previous_package, committed_package(id)) + } + + fun set_commited_package(id: &mut UID, upgrade_cap: &UpgradeCap) { + let info: &mut PackageInfo = field::borrow_mut(id, PendingPackage {}); + info.package = package::upgrade_package(upgrade_cap); + } + + fun set_authorized_digest(id: &mut UID, digest: Bytes32) { + let info: &mut PackageInfo = field::borrow_mut(id, PendingPackage {}); + info.digest = digest; + } + + fun update_package_info_from_pending(id: &mut UID) { + let pending: PackageInfo = *field::borrow(id, PendingPackage {}); + *field::borrow_mut(id, CurrentPackage {}) = pending; + } + + /// Update from version n to n+1. We enforce that the versions be kept in + /// a module called "version_control". + fun update_version_type< + Old: store + drop, + New: store + drop + >( + id: &mut UID, + _old_version: Old, + new_version: New + ) { + use std::ascii::{into_bytes}; + + assert!( + field::exists_with_type(id, CurrentVersion {}), + E_INCORRECT_OLD_VERSION + ); + let _: Old = field::remove(id, CurrentVersion {}); + + let new_type = type_name::get(); + // Make sure the new type does not equal the old type, which means there + // is no protection against either build. + assert!(new_type != type_name::get(), E_SAME_VERSION); + + // Also make sure `New` originates from this module. + let module_name = into_bytes(type_name::get_module(&new_type)); + assert!(module_name == b"version_control", E_TYPE_NOT_ALLOWED); + + // Finally add the new version. + field::add(id, CurrentVersion {}, new_version); + } + + #[test_only] + public fun remove_package_info(id: &mut UID) { + let _: PackageInfo = field::remove(id, CurrentPackage {}); + let _: PackageInfo = field::remove(id, PendingPackage {}); + } + + #[test_only] + public fun init_version( + id: &mut UID, + version: Version + ) { + field::add(id, CurrentVersion {}, version); + } + + #[test_only] + public fun update_version_type_test_only< + Old: store + drop, + New: store + drop + >( + id: &mut UID, + old_version: Old, + new_version: New + ) { + update_version_type(id, old_version, new_version) + } +} + +#[test_only] +module wormhole::package_utils_tests { + use iota::object::{Self, UID}; + use iota::tx_context::{Self}; + + use wormhole::package_utils::{Self}; + use wormhole::version_control::{Self}; + + struct State has key { + id: UID + } + + struct V_DUMMY has store, drop, copy {} + + #[test] + fun test_assert_current() { + // Create dummy state. + let state = State { id: object::new(&mut tx_context::dummy()) }; + package_utils::init_version( + &mut state.id, + version_control::current_version() + ); + + package_utils::assert_version( + &state.id, + version_control::current_version() + ); + + // Clean up. + let State { id } = state; + object::delete(id); + } + + #[test] + #[expected_failure(abort_code = package_utils::E_INCORRECT_OLD_VERSION)] + fun test_cannot_update_incorrect_old_version() { + // Create dummy state. + let state = State { id: object::new(&mut tx_context::dummy()) }; + package_utils::init_version( + &mut state.id, + version_control::current_version() + ); + + package_utils::assert_version( + &state.id, + version_control::current_version() + ); + + // You shall not pass! + package_utils::update_version_type_test_only( + &mut state.id, + version_control::next_version(), + version_control::next_version() + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = package_utils::E_SAME_VERSION)] + fun test_cannot_update_same_version() { + // Create dummy state. + let state = State { id: object::new(&mut tx_context::dummy()) }; + package_utils::init_version( + &mut state.id, + version_control::current_version() + ); + + package_utils::assert_version( + &state.id, + version_control::current_version() + ); + + // You shall not pass! + package_utils::update_version_type_test_only( + &mut state.id, + version_control::current_version(), + version_control::current_version() + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_assert_current_outdated_version() { + // Create dummy state. + let state = State { id: object::new(&mut tx_context::dummy()) }; + package_utils::init_version( + &mut state.id, + version_control::current_version() + ); + + package_utils::assert_version( + &state.id, + version_control::current_version() + ); + + // Valid update. + package_utils::update_version_type_test_only( + &mut state.id, + version_control::current_version(), + version_control::next_version() + ); + + // You shall not pass! + package_utils::assert_version( + &state.id, + version_control::current_version() + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = package_utils::E_TYPE_NOT_ALLOWED)] + fun test_cannot_update_type_not_allowed() { + // Create dummy state. + let state = State { id: object::new(&mut tx_context::dummy()) }; + package_utils::init_version( + &mut state.id, + version_control::current_version() + ); + + package_utils::assert_version( + &state.id, + version_control::current_version() + ); + + // You shall not pass! + package_utils::update_version_type_test_only( + &mut state.id, + version_control::current_version(), + V_DUMMY {} + ); + + abort 42 + } + + #[test] + fun test_latest_version_different_from_previous() { + let prev = version_control::previous_version(); + let curr = version_control::current_version(); + assert!(package_utils::type_of_version(prev) != package_utils::type_of_version(curr), 0); + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/vaa.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/vaa.move new file mode 100644 index 0000000000..0242bbf4c4 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/vaa.move @@ -0,0 +1,782 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a mechanism to parse and verify VAAs, which are +/// verified Wormhole messages (messages with Guardian signatures attesting to +/// its observation). Signatures on VAA are checked against an existing Guardian +/// set that exists in the `State` (see `wormhole::state`). +/// +/// A Wormhole integrator is discouraged from integrating `parse_and_verify` in +/// his contract. If there is a breaking change to the `vaa` module, Wormhole +/// will be upgraded to prevent previous build versions of this module to work. +/// If an integrator happened to use `parse_and_verify` in his contract, he will +/// need to be prepared to upgrade his contract to take the change (by building +/// with the latest package implementation). +/// +/// Instead, an integrator is encouraged to execute a transaction block, which +/// executes `parse_and_verify` from the latest Wormhole package ID and to +/// implement his methods that require redeeming a VAA to take `VAA` as an +/// argument. +/// +/// A good example of how this methodology is implemented is how the Token +/// Bridge contract redeems its VAAs. +module wormhole::vaa { + use std::option::{Self}; + use std::vector::{Self}; + use iota::clock::{Clock}; + use iota::hash::{keccak256}; + + use wormhole::bytes::{Self}; + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::consumed_vaas::{Self, ConsumedVAAs}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + use wormhole::guardian::{Self}; + use wormhole::guardian_set::{Self, GuardianSet}; + use wormhole::guardian_signature::{Self, GuardianSignature}; + use wormhole::state::{Self, State}; + + /// Incorrect VAA version. + const E_WRONG_VERSION: u64 = 0; + /// Not enough guardians attested to this Wormhole observation. + const E_NO_QUORUM: u64 = 1; + /// Signature does not match expected Guardian public key. + const E_INVALID_SIGNATURE: u64 = 2; + /// Prior guardian set is no longer valid. + const E_GUARDIAN_SET_EXPIRED: u64 = 3; + /// Guardian signature is encoded out of sequence. + const E_NON_INCREASING_SIGNERS: u64 = 4; + + const VERSION_VAA: u8 = 1; + + /// Container storing verified Wormhole message info. This struct also + /// caches the digest, which is a double Keccak256 hash of the message body. + struct VAA { + /// Guardian set index of Guardians that attested to observing the + /// Wormhole message. + guardian_set_index: u32, + /// Time when Wormhole message was emitted or observed. + timestamp: u32, + /// A.K.A. Batch ID. + nonce: u32, + /// Wormhole chain ID from which network the message originated from. + emitter_chain: u16, + /// Address of contract (standardized to 32 bytes) that produced the + /// message. + emitter_address: ExternalAddress, + /// Sequence number of emitter's Wormhole message. + sequence: u64, + /// A.K.A. Finality. + consistency_level: u8, + /// Arbitrary payload encoding data relevant to receiver. + payload: vector, + + /// Double Keccak256 hash of message body. + digest: Bytes32 + } + + public fun guardian_set_index(self: &VAA): u32 { + self.guardian_set_index + } + + public fun timestamp(self: &VAA): u32 { + self.timestamp + } + + public fun nonce(self: &VAA): u32 { + self.nonce + } + + public fun batch_id(self: &VAA): u32 { + nonce(self) + } + + public fun payload(self: &VAA): vector { + self.payload + } + + public fun digest(self: &VAA): Bytes32 { + self.digest + } + + public fun emitter_chain(self: &VAA): u16 { + self.emitter_chain + } + + public fun emitter_address(self: &VAA): ExternalAddress { + self.emitter_address + } + + public fun emitter_info(self: &VAA): (u16, ExternalAddress, u64) { + (self.emitter_chain, self.emitter_address, self.sequence) + } + + public fun sequence(self: &VAA): u64 { + self.sequence + } + + public fun consistency_level(self: &VAA): u8 { + self.consistency_level + } + + public fun finality(self: &VAA): u8 { + consistency_level(self) + } + + /// Destroy the `VAA` and take the Wormhole message payload. + public fun take_payload(vaa: VAA): vector { + let (_, _, payload) = take_emitter_info_and_payload(vaa); + + payload + } + + /// Destroy the `VAA` and take emitter info (chain and address) and Wormhole + /// message payload. + public fun take_emitter_info_and_payload( + vaa: VAA + ): (u16, ExternalAddress, vector) { + let VAA { + guardian_set_index: _, + timestamp: _, + nonce: _, + emitter_chain, + emitter_address, + sequence: _, + consistency_level: _, + digest: _, + payload, + } = vaa; + (emitter_chain, emitter_address, payload) + } + + /// Parses and verifies the signatures of a VAA. + /// + /// NOTE: This is the only public function that returns a VAA, and it should + /// be kept that way. This ensures that if an external module receives a + /// `VAA`, it has been verified. + public fun parse_and_verify( + wormhole_state: &State, + buf: vector, + the_clock: &Clock + ): VAA { + state::assert_latest_only(wormhole_state); + + // Deserialize VAA buffer (and return `VAA` after verifying signatures). + let (signatures, vaa) = parse(buf); + + // Fetch the guardian set which this VAA was supposedly signed with and + // verify signatures using guardian set. + verify_signatures( + state::guardian_set_at( + wormhole_state, + vaa.guardian_set_index + ), + signatures, + bytes32::to_bytes(compute_message_hash(&vaa)), + the_clock + ); + + // Done. + vaa + } + + public fun consume(consumed: &mut ConsumedVAAs, parsed: &VAA) { + consumed_vaas::consume(consumed, digest(parsed)) + } + + public fun compute_message_hash(parsed: &VAA): Bytes32 { + let buf = vector::empty(); + + bytes::push_u32_be(&mut buf, parsed.timestamp); + bytes::push_u32_be(&mut buf, parsed.nonce); + bytes::push_u16_be(&mut buf, parsed.emitter_chain); + vector::append( + &mut buf, + external_address::to_bytes(parsed.emitter_address) + ); + bytes::push_u64_be(&mut buf, parsed.sequence); + bytes::push_u8(&mut buf, parsed.consistency_level); + vector::append(&mut buf, parsed.payload); + + // Return hash. + bytes32::new(keccak256(&buf)) + } + + /// Parses a VAA. + /// + /// NOTE: This method does NOT perform any verification. This ensures the + /// invariant that if an external module receives a `VAA` object, its + /// signatures must have been verified, because the only public function + /// that returns a `VAA` is `parse_and_verify`. + fun parse(buf: vector): (vector, VAA) { + let cur = cursor::new(buf); + + // Check VAA version. + assert!( + bytes::take_u8(&mut cur) == VERSION_VAA, + E_WRONG_VERSION + ); + + let guardian_set_index = bytes::take_u32_be(&mut cur); + + // Deserialize guardian signatures. + let num_signatures = bytes::take_u8(&mut cur); + let signatures = vector::empty(); + let i = 0; + while (i < num_signatures) { + let guardian_index = bytes::take_u8(&mut cur); + let r = bytes32::take_bytes(&mut cur); + let s = bytes32::take_bytes(&mut cur); + let recovery_id = bytes::take_u8(&mut cur); + vector::push_back( + &mut signatures, + guardian_signature::new(r, s, recovery_id, guardian_index) + ); + i = i + 1; + }; + + // Deserialize message body. + let body_buf = cursor::take_rest(cur); + + let cur = cursor::new(body_buf); + let timestamp = bytes::take_u32_be(&mut cur); + let nonce = bytes::take_u32_be(&mut cur); + let emitter_chain = bytes::take_u16_be(&mut cur); + let emitter_address = external_address::take_bytes(&mut cur); + let sequence = bytes::take_u64_be(&mut cur); + let consistency_level = bytes::take_u8(&mut cur); + let payload = cursor::take_rest(cur); + + let parsed = VAA { + guardian_set_index, + timestamp, + nonce, + emitter_chain, + emitter_address, + sequence, + consistency_level, + digest: double_keccak256(body_buf), + payload, + }; + + (signatures, parsed) + } + + fun double_keccak256(buf: vector): Bytes32 { + use iota::hash::{keccak256}; + + bytes32::new(keccak256(&keccak256(&buf))) + } + + /// Using the Guardian signatures deserialized from VAA, verify that all of + /// the Guardian public keys are recovered using these signatures and the + /// VAA message body as the message used to produce these signatures. + /// + /// We are careful to only allow `wormhole:vaa` to control the hash that + /// gets used in the `ecdsa_k1` module by computing the hash after + /// deserializing the VAA message body. Even though `ecdsa_k1` hashes a + /// raw message (as of version 0.28), the "raw message" in this case is a + /// single keccak256 hash of the VAA message body. + fun verify_signatures( + set: &GuardianSet, + signatures: vector, + message_hash: vector, + the_clock: &Clock + ) { + // Guardian set must be active (not expired). + assert!( + guardian_set::is_active(set, the_clock), + E_GUARDIAN_SET_EXPIRED + ); + + // Number of signatures must be at least quorum. + assert!( + vector::length(&signatures) >= guardian_set::quorum(set), + E_NO_QUORUM + ); + + // Drain `Cursor` by checking each signature. + let cur = cursor::new(signatures); + let last_guardian_index = option::none(); + while (!cursor::is_empty(&cur)) { + let signature = cursor::poke(&mut cur); + let guardian_index = guardian_signature::index_as_u64(&signature); + + // Ensure that the provided signatures are strictly increasing. + // This check makes sure that no duplicate signers occur. The + // increasing order is guaranteed by the guardians, or can always be + // reordered by the client. + assert!( + ( + option::is_none(&last_guardian_index) || + guardian_index > *option::borrow(&last_guardian_index) + ), + E_NON_INCREASING_SIGNERS + ); + + // If the guardian pubkey cannot be recovered using the signature + // and message hash, revert. + assert!( + guardian::verify( + guardian_set::guardian_at(set, guardian_index), + signature, + message_hash + ), + E_INVALID_SIGNATURE + ); + + // Continue. + option::swap_or_fill(&mut last_guardian_index, guardian_index); + }; + + // Done. + cursor::destroy_empty(cur); + } + + #[test_only] + public fun parse_test_only( + buf: vector + ): (vector, VAA) { + parse(buf) + } + + #[test_only] + public fun destroy(vaa: VAA) { + take_payload(vaa); + } + + #[test_only] + public fun peel_payload_from_vaa(buf: &vector): vector { + // Just make sure that we are passing version 1 VAAs to this method. + assert!(*vector::borrow(buf, 0) == VERSION_VAA, E_WRONG_VERSION); + + // Find the location of the payload. + let num_signatures = (*vector::borrow(buf, 5) as u64); + let i = 57 + num_signatures * 66; + + // Push the payload bytes to `out` and return. + let out = vector::empty(); + let len = vector::length(buf); + while (i < len) { + vector::push_back(&mut out, *vector::borrow(buf, i)); + i = i + 1; + }; + + // Return the payload. + out + } +} + +#[test_only] +module wormhole::vaa_tests { + use std::vector::{Self}; + use iota::test_scenario::{Self}; + + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self}; + use wormhole::guardian_signature::{Self}; + use wormhole::state::{Self}; + use wormhole::vaa::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + guardians, + person, + return_clock, + return_state, + set_up_wormhole_with_guardians, + take_clock, + take_state + //upgrade_wormhole + }; + + const VAA_1: vector = + x"01000000000d009bafff633087a9587d9afb6d29bd74a3483b7a8d5619323a416fe9ca43b482cd5526fabe953157cfd42eea9ffa544babc0f3a025a8a6159217b96fc9ff586d560002c9367884940a43a1a4d86531ea33ccb41e52bd7d1679c106fdff756f3da2ca743f7c181fcf40d19151d0a8397335c1b71709279b6e4fa97b6e3de90824e841c801035a493b65bf12ab9b98aa4db3bfcb73df20ab854d8e5998a1552f3b3e57ea7cd3546187c62cd450d12d430cae0fb48124ae68034dae602fa3e2232b55257961f90104758e265101353923661f6df67cec3c38528ed1b68825099b5bb2ce3fb2e735c5073d90223bebd00cc10406a60413a6089b5fb9acee0a1b04a63a8d7db24c0bbc000587777306dd174e266c313f711e881086355b6ce66cf2bf1f5da58273a10be77813b5ffcafc1ba6b83645e326a7c1a3751496f279ba307a6cd554f2709c2f1eda0108ed23ba8264146c3e3cc0601c93260c25058bcdd25213a7834e51679afdc4b50104e3f3a3079ba45115e703096c7e0700354cd48348bbf686dcbc58be896c35a20009c2352cb46ef1d2ef9e185764650403aee87a1be071555b31cdcee0c346991da858defb8d5e164a293ce4377b54fc74b65e3acbdedcbb53c2bcc2688a0b5bd1c9010ae470b1573989f387f7c54a86325cc05978bbcbc13267e90e2fa2efb0e18bccb772252bd6d13ebf908f7f3f2caf20a45c17dec7168122a2535ea93d300fae7063000ba0e8770298d4e3567488f455455a33f1e723e1e629ba4f87928016aeaa5875561ec38bde5d934389dc657d80a927cd9d06a9d9c7ce910c98d77a576e3f31735c000eeeedc956cff4489ac55b52ca38233cdc11e88767e5cc82f664bd1d7c28dfb5a12d7d17620725aae08e499b021200919f42c50c05916cf425dcd6e59f24b4b233000f18d447c9608a076c066b30ee770910e3c133087d33e329ad0101f08f88d88e142623df87aa3842edcf34e10fd36271b49f7af73ff2a7bcf4a65a4306d59586f20111905fc99dc650d9b1b33c313e9b31dfdbc85ce57e9f31abc4841d5791a239f20e5f28e4e612db96aee2f49ae712f724466007aaf27309d0385005fe0264d33dd100127b46f2fbbbf12efb10c2e662b4449de404f6a408ad7f38c7ea40a46300930e9a3b1e02ce00b97e33fa8a87221c1fd9064ce966dc4772658b98f2ec1e28d13e7400000023280000000c002adeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef000000000000092a20416c6c20796f75722062617365206172652062656c6f6e6720746f207573"; + const VAA_DOUBLE_SIGNED: vector = + x"01000000000d009bafff633087a9587d9afb6d29bd74a3483b7a8d5619323a416fe9ca43b482cd5526fabe953157cfd42eea9ffa544babc0f3a025a8a6159217b96fc9ff586d560002c9367884940a43a1a4d86531ea33ccb41e52bd7d1679c106fdff756f3da2ca743f7c181fcf40d19151d0a8397335c1b71709279b6e4fa97b6e3de90824e841c80102c9367884940a43a1a4d86531ea33ccb41e52bd7d1679c106fdff756f3da2ca743f7c181fcf40d19151d0a8397335c1b71709279b6e4fa97b6e3de90824e841c801035a493b65bf12ab9b98aa4db3bfcb73df20ab854d8e5998a1552f3b3e57ea7cd3546187c62cd450d12d430cae0fb48124ae68034dae602fa3e2232b55257961f90104758e265101353923661f6df67cec3c38528ed1b68825099b5bb2ce3fb2e735c5073d90223bebd00cc10406a60413a6089b5fb9acee0a1b04a63a8d7db24c0bbc000587777306dd174e266c313f711e881086355b6ce66cf2bf1f5da58273a10be77813b5ffcafc1ba6b83645e326a7c1a3751496f279ba307a6cd554f2709c2f1eda0108ed23ba8264146c3e3cc0601c93260c25058bcdd25213a7834e51679afdc4b50104e3f3a3079ba45115e703096c7e0700354cd48348bbf686dcbc58be896c35a20009c2352cb46ef1d2ef9e185764650403aee87a1be071555b31cdcee0c346991da858defb8d5e164a293ce4377b54fc74b65e3acbdedcbb53c2bcc2688a0b5bd1c9010ae470b1573989f387f7c54a86325cc05978bbcbc13267e90e2fa2efb0e18bccb772252bd6d13ebf908f7f3f2caf20a45c17dec7168122a2535ea93d300fae7063000ba0e8770298d4e3567488f455455a33f1e723e1e629ba4f87928016aeaa5875561ec38bde5d934389dc657d80a927cd9d06a9d9c7ce910c98d77a576e3f31735c000f18d447c9608a076c066b30ee770910e3c133087d33e329ad0101f08f88d88e142623df87aa3842edcf34e10fd36271b49f7af73ff2a7bcf4a65a4306d59586f20111905fc99dc650d9b1b33c313e9b31dfdbc85ce57e9f31abc4841d5791a239f20e5f28e4e612db96aee2f49ae712f724466007aaf27309d0385005fe0264d33dd100127b46f2fbbbf12efb10c2e662b4449de404f6a408ad7f38c7ea40a46300930e9a3b1e02ce00b97e33fa8a87221c1fd9064ce966dc4772658b98f2ec1e28d13e7400000023280000000c002adeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef000000000000092a20416c6c20796f75722062617365206172652062656c6f6e6720746f207573"; + const VAA_NO_QUORUM: vector = + x"01000000000c009bafff633087a9587d9afb6d29bd74a3483b7a8d5619323a416fe9ca43b482cd5526fabe953157cfd42eea9ffa544babc0f3a025a8a6159217b96fc9ff586d560002c9367884940a43a1a4d86531ea33ccb41e52bd7d1679c106fdff756f3da2ca743f7c181fcf40d19151d0a8397335c1b71709279b6e4fa97b6e3de90824e841c801035a493b65bf12ab9b98aa4db3bfcb73df20ab854d8e5998a1552f3b3e57ea7cd3546187c62cd450d12d430cae0fb48124ae68034dae602fa3e2232b55257961f90104758e265101353923661f6df67cec3c38528ed1b68825099b5bb2ce3fb2e735c5073d90223bebd00cc10406a60413a6089b5fb9acee0a1b04a63a8d7db24c0bbc000587777306dd174e266c313f711e881086355b6ce66cf2bf1f5da58273a10be77813b5ffcafc1ba6b83645e326a7c1a3751496f279ba307a6cd554f2709c2f1eda0108ed23ba8264146c3e3cc0601c93260c25058bcdd25213a7834e51679afdc4b50104e3f3a3079ba45115e703096c7e0700354cd48348bbf686dcbc58be896c35a20009c2352cb46ef1d2ef9e185764650403aee87a1be071555b31cdcee0c346991da858defb8d5e164a293ce4377b54fc74b65e3acbdedcbb53c2bcc2688a0b5bd1c9010ae470b1573989f387f7c54a86325cc05978bbcbc13267e90e2fa2efb0e18bccb772252bd6d13ebf908f7f3f2caf20a45c17dec7168122a2535ea93d300fae7063000ba0e8770298d4e3567488f455455a33f1e723e1e629ba4f87928016aeaa5875561ec38bde5d934389dc657d80a927cd9d06a9d9c7ce910c98d77a576e3f31735c000f18d447c9608a076c066b30ee770910e3c133087d33e329ad0101f08f88d88e142623df87aa3842edcf34e10fd36271b49f7af73ff2a7bcf4a65a4306d59586f20111905fc99dc650d9b1b33c313e9b31dfdbc85ce57e9f31abc4841d5791a239f20e5f28e4e612db96aee2f49ae712f724466007aaf27309d0385005fe0264d33dd100127b46f2fbbbf12efb10c2e662b4449de404f6a408ad7f38c7ea40a46300930e9a3b1e02ce00b97e33fa8a87221c1fd9064ce966dc4772658b98f2ec1e28d13e7400000023280000000c002adeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef000000000000092a20416c6c20796f75722062617365206172652062656c6f6e6720746f207573"; + + #[test] + fun test_parse() { + let (signatures, parsed) = vaa::parse_test_only(VAA_1); + + let expected_signatures = + vector[ + guardian_signature::new( + bytes32::new( + x"9bafff633087a9587d9afb6d29bd74a3483b7a8d5619323a416fe9ca43b482cd" + ), // r + bytes32::new( + x"5526fabe953157cfd42eea9ffa544babc0f3a025a8a6159217b96fc9ff586d56" + ), // s + 0, // recovery_id + 0 // index + ), + guardian_signature::new( + bytes32::new( + x"c9367884940a43a1a4d86531ea33ccb41e52bd7d1679c106fdff756f3da2ca74" + ), // r + bytes32::new( + x"3f7c181fcf40d19151d0a8397335c1b71709279b6e4fa97b6e3de90824e841c8" + ), // s + 1, // recovery_id + 2 // index + ), + guardian_signature::new( + bytes32::new( + x"5a493b65bf12ab9b98aa4db3bfcb73df20ab854d8e5998a1552f3b3e57ea7cd3" + ), // r + bytes32::new( + x"546187c62cd450d12d430cae0fb48124ae68034dae602fa3e2232b55257961f9" + ), // s + 1, // recovery_id + 3 // index + ), + guardian_signature::new( + bytes32::new( + x"758e265101353923661f6df67cec3c38528ed1b68825099b5bb2ce3fb2e735c5" + ), // r + bytes32::new( + x"073d90223bebd00cc10406a60413a6089b5fb9acee0a1b04a63a8d7db24c0bbc" + ), // s + 0, // recovery_id + 4 // index + ), + guardian_signature::new( + bytes32::new( + x"87777306dd174e266c313f711e881086355b6ce66cf2bf1f5da58273a10be778" + ), // r + bytes32::new( + x"13b5ffcafc1ba6b83645e326a7c1a3751496f279ba307a6cd554f2709c2f1eda" + ), // s + 1, // recovery_id + 5 // index + ), + guardian_signature::new( + bytes32::new( + x"ed23ba8264146c3e3cc0601c93260c25058bcdd25213a7834e51679afdc4b501" + ), // r + bytes32::new( + x"04e3f3a3079ba45115e703096c7e0700354cd48348bbf686dcbc58be896c35a2" + ), // s + 0, // recovery_id + 8 // index + ), + guardian_signature::new( + bytes32::new( + x"c2352cb46ef1d2ef9e185764650403aee87a1be071555b31cdcee0c346991da8" + ), // r + bytes32::new( + x"58defb8d5e164a293ce4377b54fc74b65e3acbdedcbb53c2bcc2688a0b5bd1c9" + ), // s + 1, // recovery_id + 9 // index + ), + guardian_signature::new( + bytes32::new( + x"e470b1573989f387f7c54a86325cc05978bbcbc13267e90e2fa2efb0e18bccb7" + ), // r + bytes32::new( + x"72252bd6d13ebf908f7f3f2caf20a45c17dec7168122a2535ea93d300fae7063" + ), // s + 0, // recovery_id + 10 // index + ), + guardian_signature::new( + bytes32::new( + x"a0e8770298d4e3567488f455455a33f1e723e1e629ba4f87928016aeaa587556" + ), // r + bytes32::new( + x"1ec38bde5d934389dc657d80a927cd9d06a9d9c7ce910c98d77a576e3f31735c" + ), // s + 0, // recovery_id + 11 // index + ), + guardian_signature::new( + bytes32::new( + x"eeedc956cff4489ac55b52ca38233cdc11e88767e5cc82f664bd1d7c28dfb5a1" + ), // r + bytes32::new( + x"2d7d17620725aae08e499b021200919f42c50c05916cf425dcd6e59f24b4b233" + ), // s + 0, // recovery_id + 14 // index + ), + guardian_signature::new( + bytes32::new( + x"18d447c9608a076c066b30ee770910e3c133087d33e329ad0101f08f88d88e14" + ), // r + bytes32::new( + x"2623df87aa3842edcf34e10fd36271b49f7af73ff2a7bcf4a65a4306d59586f2" + ), // s + 1, // recovery_id + 15 // index + ), + guardian_signature::new( + bytes32::new( + x"905fc99dc650d9b1b33c313e9b31dfdbc85ce57e9f31abc4841d5791a239f20e" + ), // r + bytes32::new( + x"5f28e4e612db96aee2f49ae712f724466007aaf27309d0385005fe0264d33dd1" + ), // s + 0, // recovery_id + 17 // index + ), + guardian_signature::new( + bytes32::new( + x"7b46f2fbbbf12efb10c2e662b4449de404f6a408ad7f38c7ea40a46300930e9a" + ), // r + bytes32::new( + x"3b1e02ce00b97e33fa8a87221c1fd9064ce966dc4772658b98f2ec1e28d13e74" + ), // s + 0, // recovery_id + 18 // index + ) + ]; + assert!( + vector::length(&signatures) == vector::length(&expected_signatures), + 0 + ); + let left = cursor::new(signatures); + let right = cursor::new(expected_signatures); + while (!cursor::is_empty(&left)) { + assert!(cursor::poke(&mut left) == cursor::poke(&mut right), 0); + }; + cursor::destroy_empty(left); + cursor::destroy_empty(right); + + assert!(vaa::guardian_set_index(&parsed) == 0, 0); + assert!(vaa::timestamp(&parsed) == 9000, 0); + + let expected_batch_id = 12; + assert!(vaa::batch_id(&parsed) == expected_batch_id, 0); + assert!(vaa::nonce(&parsed) == expected_batch_id, 0); + + assert!(vaa::emitter_chain(&parsed) == 42, 0); + + let expected_emitter_address = + external_address::from_address( + @0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef + ); + assert!(vaa::emitter_address(&parsed) == expected_emitter_address, 0); + assert!(vaa::sequence(&parsed) == 2346, 0); + + let expected_finality = 32; + assert!(vaa::finality(&parsed) == expected_finality, 0); + assert!(vaa::consistency_level(&parsed) == expected_finality, 0); + + // The message Wormhole guardians sign is a hash of the actual message + // body. So the hash we need to check against is keccak256 of this + // message. + let body_buf = { + use wormhole::bytes::{Self}; + + let buf = vector::empty(); + bytes::push_u32_be(&mut buf, vaa::timestamp(&parsed)); + bytes::push_u32_be(&mut buf, vaa::nonce(&parsed)); + bytes::push_u16_be(&mut buf, vaa::emitter_chain(&parsed)); + vector::append( + &mut buf, + external_address::to_bytes(vaa::emitter_address(&parsed)) + ); + bytes::push_u64_be(&mut buf, vaa::sequence(&parsed)); + bytes::push_u8(&mut buf, vaa::consistency_level(&parsed)); + vector::append(&mut buf, vaa::payload(&parsed)); + + buf + }; + + let expected_message_hash = + bytes32::new(iota::hash::keccak256(&body_buf)); + assert!(vaa::compute_message_hash(&parsed) == expected_message_hash, 0); + + let expected_digest = + bytes32::new( + iota::hash::keccak256(&iota::hash::keccak256(&body_buf)) + ); + assert!(vaa::digest(&parsed) == expected_digest, 0); + + assert!( + vaa::take_payload(parsed) == b"All your base are belong to us", + 0 + ); + } + + #[test] + fun test_parse_and_verify() { + // Testing this method. + use wormhole::vaa::{parse_and_verify}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole with 19 guardians. + let wormhole_fee = 350; + set_up_wormhole_with_guardians(scenario, wormhole_fee, guardians()); + + // Prepare test to execute `parse_and_verify`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = parse_and_verify(&worm_state, VAA_1, &the_clock); + + // We verified all parsed output in `test_parse`. But in destroying the + // parsed VAA, we will check the payload for the heck of it. + assert!( + vaa::take_payload(verified_vaa) == b"All your base are belong to us", + 0 + ); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = vaa::E_NO_QUORUM)] + fun test_cannot_parse_and_verify_without_quorum() { + // Testing this method. + use wormhole::vaa::{parse_and_verify}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole with 19 guardians. + let wormhole_fee = 350; + set_up_wormhole_with_guardians(scenario, wormhole_fee, guardians()); + + // Prepare test to execute `parse_and_verify`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // You shall not pass! + let verified_vaa = parse_and_verify(&worm_state, VAA_NO_QUORUM, &the_clock); + + // Clean up. + vaa::destroy(verified_vaa); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = vaa::E_NON_INCREASING_SIGNERS)] + fun test_cannot_parse_and_verify_non_increasing() { + // Testing this method. + use wormhole::vaa::{parse_and_verify}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole with 19 guardians. + let wormhole_fee = 350; + set_up_wormhole_with_guardians(scenario, wormhole_fee, guardians()); + + // Prepare test to execute `parse_and_verify`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // You shall not pass! + let verified_vaa = + parse_and_verify(&worm_state, VAA_DOUBLE_SIGNED, &the_clock); + + // Clean up. + vaa::destroy(verified_vaa); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = vaa::E_INVALID_SIGNATURE)] + fun test_cannot_parse_and_verify_invalid_signature() { + // Testing this method. + use wormhole::vaa::{parse_and_verify}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole with 19 guardians. But reverse the order so the + // signatures will not match. + let initial_guardians = guardians(); + std::vector::reverse(&mut initial_guardians); + + let wormhole_fee = 350; + set_up_wormhole_with_guardians( + scenario, + wormhole_fee, + initial_guardians + ); + + // Prepare test to execute `parse_and_verify`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // You shall not pass! + let verified_vaa = parse_and_verify(&worm_state, VAA_1, &the_clock); + + // Clean up. + vaa::destroy(verified_vaa); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_parse_and_verify_outdated_version() { + // Testing this method. + use wormhole::vaa::{parse_and_verify}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole with 19 guardians. + let wormhole_fee = 350; + set_up_wormhole_with_guardians(scenario, wormhole_fee, guardians()); + + // Prepare test to execute `parse_and_verify`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + // You shall not pass! + let verified_vaa = parse_and_verify(&worm_state, VAA_1, &the_clock); + + // Clean up. + vaa::destroy(verified_vaa); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/version_control.move b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/version_control.move new file mode 100644 index 0000000000..6821d04072 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_iota_testnet/wormhole/sources/version_control.move @@ -0,0 +1,70 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements dynamic field keys as empty structs. These keys are +/// used to determine the latest version for this build. If the current version +/// is not this build's, then paths through the `state` module will abort. +/// +/// See `wormhole::state` and `wormhole::package_utils` for more info. +module wormhole::version_control { + //////////////////////////////////////////////////////////////////////////// + // + // Hard-coded Version Control + // + // Before upgrading, please set the types for `current_version` and + // `previous_version` to match the correct types (current being the latest + // version reflecting this build). + // + //////////////////////////////////////////////////////////////////////////// + + public(friend) fun current_version(): V__0_2_0 { + V__0_2_0 {} + } + + public(friend) fun previous_version(): V__DUMMY { + V__DUMMY {} + } + + #[test_only] + public fun previous_version_test_only(): V__DUMMY { + previous_version() + } + + //////////////////////////////////////////////////////////////////////////// + // + // Change Log + // + // Please write release notes as doc strings for each version struct. These + // notes will be our attempt at tracking upgrades. Wish us luck. + // + //////////////////////////////////////////////////////////////////////////// + + /// First published package on Iota mainnet. + struct V__0_2_0 has store, drop, copy {} + + // Dummy. + struct V__DUMMY has store, drop, copy {} + + //////////////////////////////////////////////////////////////////////////// + // + // Implementation and Test-Only Methods + // + //////////////////////////////////////////////////////////////////////////// + + friend wormhole::state; + + #[test_only] + friend wormhole::package_utils_tests; + + #[test_only] + public fun dummy(): V__DUMMY { + V__DUMMY {} + } + + #[test_only] + struct V__MIGRATED has store, drop, copy {} + + #[test_only] + public fun next_version(): V__MIGRATED { + V__MIGRATED {} + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/.gitignore b/target_chains/iota/vendor/wormhole_movement_m2_devnet/.gitignore new file mode 100644 index 0000000000..6ddb4b0ac3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/.gitignore @@ -0,0 +1,2 @@ +deploy.out +sui.log.* diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/Docker.md b/target_chains/iota/vendor/wormhole_movement_m2_devnet/Docker.md new file mode 100755 index 0000000000..97ff842f6d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/Docker.md @@ -0,0 +1,13 @@ +# first build the image + +cd ..; DOCKER_BUILDKIT=1 docker build --no-cache --progress plain -f sui/Dockerfile.base -t sui . + +# tag the image with the appropriate version + +docker tag sui:latest ghcr.io/wormhole-foundation/sui:1.19.1-mainnet + +# push to ghcr + +docker push ghcr.io/wormhole-foundation/sui:1.19.1-mainnet + +echo remember to update both Dockerfile and Dockerfile.export diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/Dockerfile b/target_chains/iota/vendor/wormhole_movement_m2_devnet/Dockerfile new file mode 100644 index 0000000000..4bef3a3624 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/Dockerfile @@ -0,0 +1,33 @@ +FROM cli-gen AS cli-export +FROM const-gen AS const-export +FROM ghcr.io/wormhole-foundation/sui:1.19.1-mainnet@sha256:544a1b2aa5701fae25a19aed3c5e8c24e0caf7d1c9f511b6844d339a8f0b2a00 as sui + +# initial run +# COPY sui/devnet/genesis_config genesis_config +# RUN sui genesis -f --from-config genesis_config + +# subsequent runs after committing files from /root/.sui/sui_config/ +COPY sui/devnet/ /root/.sui/sui_config/ + +WORKDIR /tmp + +COPY sui/scripts/ scripts +COPY sui/wormhole/ wormhole +COPY sui/token_bridge/ token_bridge +COPY sui/examples/ examples +COPY sui/Makefile Makefile + +# Copy .env and CLI +COPY --from=const-export .env .env +COPY --from=cli-export clients/js /cli + +# Link `worm` +WORKDIR /cli + +RUN npm link + +FROM sui AS tests + +WORKDIR /tmp + +RUN --mount=type=cache,target=/root/.move,id=move_cache make test diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/Dockerfile.base b/target_chains/iota/vendor/wormhole_movement_m2_devnet/Dockerfile.base new file mode 100644 index 0000000000..4c76dc016d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/Dockerfile.base @@ -0,0 +1,24 @@ +FROM rust:1.62@sha256:5777f201f507075309c4d2d1c1e8d8219e654ae1de154c844341050016a64a0c as sui-node + +WORKDIR /tmp + +RUN curl -L https://github.com/MystenLabs/sui/releases/download/mainnet-v1.19.1/sui-mainnet-v1.19.1-ubuntu-x86_64.tgz > sui-mainnet-v1.19.1-ubuntu-x86_64.tgz +RUN echo "6a8cc96759760293143a00fe7031a5fea70d2dff5b98d18c0470c09555da63e0 sui-mainnet-v1.19.1-ubuntu-x86_64.tgz" | sha256sum -c --status + +RUN tar -xvf sui-mainnet-v1.19.1-ubuntu-x86_64.tgz +RUN mv target/release/sui-ubuntu-x86_64 /bin/sui +RUN mv target/release/sui-faucet-ubuntu-x86_64 /bin/sui-faucet +RUN mv target/release/sui-node-ubuntu-x86_64 /bin/sui-node + +RUN rm sui-mainnet-v1.19.1-ubuntu-x86_64.tgz + +RUN apt-get update +RUN apt-get install -y ca-certificates curl gnupg +RUN mkdir -p /etc/apt/keyrings +RUN curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg + +ARG NODE_MAJOR=18 +RUN echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_$NODE_MAJOR.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list + +RUN apt-get update +RUN apt-get install nodejs -y diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/Makefile b/target_chains/iota/vendor/wormhole_movement_m2_devnet/Makefile new file mode 100644 index 0000000000..0ee0e5eb94 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/Makefile @@ -0,0 +1,15 @@ +TEST_CONTRACT_DIRS := wormhole token_bridge examples/coins examples/core_messages +CLEAN_CONTRACT_DIRS := wormhole token_bridge examples/coins examples/core_messages + +.PHONY: clean +clean: + $(foreach dir,$(TEST_CONTRACT_DIRS), make -C $(dir) $@ &&) true + +.PHONY: test +test: + $(foreach dir,$(TEST_CONTRACT_DIRS), make -C $(dir) $@ &&) true + +test-docker: + DOCKER_BUILDKIT=1 docker build --progress plain -f ../Dockerfile.cli -t cli-gen .. + DOCKER_BUILDKIT=1 docker build --build-arg num_guardians=1 --progress plain -f ../Dockerfile.const -t const-gen .. + DOCKER_BUILDKIT=1 docker build -f Dockerfile .. diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/NOTES.md b/target_chains/iota/vendor/wormhole_movement_m2_devnet/NOTES.md new file mode 100644 index 0000000000..5677cfb924 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/NOTES.md @@ -0,0 +1,114 @@ +brew install cmake + + rustup install stable-x86_64-apple-darwin + #rustup target add stable-x86_64-apple-darwin + rustup target add x86_64-apple-darwin + +=== Building + + % ./node_builder.sh + +=== Running + + % ./start_node.sh + +# If you don't remember your newly generated address + + % sui client addresses + Showing 1 results. + 0x13b3cb89cf3226d3b860294fc75dc6c91f0c5ecf + +# Give yourself some money + + % scripts/faucet.sh `sui client addresses | tail -1` + +# Looking at the prefunded address + + % sui client objects --address 0x13b3cb89cf3226d3b860294fc75dc6c91f0c5ecf + +=== Boot tilt + +# fund our standard account + + We don't run a faucet since it doesn't always unlock the client LOCK files. So, instead we just steal a chunk of coins + from the default accounts created when the node was initialized. Once sui is showing as live... + +``` sh + % kubectl exec -it sui-0 -c sui-node -- /tmp/funder.sh +``` + +# getting into the sui k8s node (if you need to crawl around) + + kubectl exec -it sui-0 -c sui-node -- /bin/bash + kubectl exec -it guardian-0 -c guardiand -- /bin/bash + +# setup the client.yaml + +``` sh + % rm -rf $HOME/.sui + % sui keytool import "daughter exclude wheat pudding police weapon giggle taste space whip satoshi occur" ed25519 + % sui client +``` + point it at http://localhost:9000. The key you create doesn't matter. + +# edit $HOME/.sui/sui_config/client.yaml + +``` sh + sed -i -e 's/active_address.*/active_address: "0x13b3cb89cf3226d3b860294fc75dc6c91f0c5ecf"/' ~/.sui/sui_config/client.yaml +``` + + +# deploy the contract + +``` sh + % scripts/deploy.sh +``` + +# start the watcher + +``` sh + % . env.sh + % python3 tests/ws.py +``` + +# publish a message (different window) + +``` sh + % . env.sh + % scripts/publish_message.sh +``` + +== + +docker run -it -v `pwd`:`pwd` -w `pwd` --net=host ghcr.io/wormhole-foundation/sui:0.16.0 bash +dnf -y install git make + +``` sh + % rm -rf $HOME/.sui + % sui keytool import "daughter exclude wheat pudding police weapon giggle taste space whip satoshi occur" secp256k1 + % sui client +``` + +to get a new emitter + + kubectl exec -it sui-0 -c sui-node -- /tmp/funder.sh + scripts/deploy.sh + . env.sh + sui client call --function get_new_emitter --module wormhole --package $WORM_PACKAGE --gas-budget 20000 --args \"$WORM_STATE\" + + sui client objects + scripts/publish_message.sh 0x165ef7366c4267c6506bcf63d2419556f34f48d6 + + +curl -s -X POST -d '{"jsonrpc":"2.0", "id": 1, "method": "sui_getEvents", "params": [{"MoveEvent": "0xf4179152ab02e4212d7e7b20f37a9a86ab6d50fb::state::WormholeMessage"}, null, 10, true]}' -H 'Content-Type: application/json' http://127.0.0.1:9002 | jq + +curl -s -X POST -d '{"jsonrpc":"2.0", "id": 1, "method": "sui_getEvents", "params": [{"Transaction": "cL+uWFEVcQrkAiOxOJmaK7JmlOJdE3/8X5JFbJwBxCQ="}, null, 10, true]}' -H 'Content-Type: application/json' http://127.0.0.1:9002 | jq + +"txhash": "0x70bfae585115710ae40223b138999a2bb26694e25d137ffc5f92456c9c01c424", "txhash_b58": "8b8Bn8MUqAWeVz2BE5hMicC9KaRkV6UM4v1JLWGUjxcT", " +Digest: cL+uWFEVcQrkAiOxOJmaK7JmlOJdE3/8X5JFbJwBxCQ= + + kubectl exec -it guardian-0 -- /guardiand admin send-observation-request --socket /tmp/admin.sock 21 70bfae585115710ae40223b138999a2bb26694e25d137ffc5f92456c9c01c424 + +// curl -s -X POST -d '{"jsonrpc":"2.0", "id": 1, "method": "sui_getCommitteeInfo", "params": []}' -H 'Content-Type: application/json' http://127.0.0.1:9002 | jq + +// curl -s -X POST -d '{"jsonrpc":"2.0", "id": 1, "method": "sui_getLatestCheckpointSequenceNumber", "params": []}' -H 'Content-Type: application/json' http://127.0.0.1:9000 diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/README.md b/target_chains/iota/vendor/wormhole_movement_m2_devnet/README.md new file mode 100644 index 0000000000..729a8c406c --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/README.md @@ -0,0 +1,130 @@ +# Wormhole on Sui + +This folder contains the reference implementation of the Wormhole cross-chain +messaging protocol smart contracts on the [Sui](https://mystenlabs.com/) +blockchain, implemented in the [Move](https://move-book.com/) programming +language. + +# Project structure + +The project is laid out as follows: + +- [wormhole](./wormhole) the core messaging layer +- [token_bridge](./token_bridge) the asset transfer layer +- [coin](./coin) a template for creating Wormhole wrapped coins + +# Installation + +Make sure your Cargo version is at least 1.65.0 and then follow the steps below: + +- https://docs.sui.io/build/install + +#https://docs.sui.io/guides/developer/getting-started/sui-install# Prerequisites + +Install the `Sui` CLI. This tool is used to compile the contracts and run the tests. + +```sh +cargo install --locked --git https://github.com/MystenLabs/sui.git --rev 041c5f2bae2fe52079e44b70514333532d69f4e6 sui +``` + +Some useful Sui CLI commands are + +- `sui start` to spin up a local network +- `rpc-server` to start a server for handling rpc calls + +Next, install the [worm](../clients/js/README.md) CLI tool by running + +```sh +wormhole/clients/js $ make install +``` + +`worm` is the swiss army knife for interacting with wormhole contracts on all +supported chains, and generating signed messages (VAAs) for testing. + +As an optional, but recommended step, install the +[move-analyzer](https://github.com/move-language/move/tree/main/language/move-analyzer) +Language Server (LSP): + +```sh +cargo install --git https://github.com/move-language/move.git move-analyzer --branch main --features "address32" +``` + +This installs the LSP backend which is then supported by most popular editors such as [emacs](https://github.com/emacs-lsp/lsp-mode), [vim](https://github.com/neoclide/coc.nvim), and even [vscode](https://marketplace.visualstudio.com/items?itemName=move.move-analyzer). + +
+ For emacs, you may need to add the following to your config file: + +```lisp +;; Move +(define-derived-mode move-mode rust-mode "Move" + :group 'move-mode) + +(add-to-list 'auto-mode-alist '("\\.move\\'" . move-mode)) + +(with-eval-after-load 'lsp-mode + (add-to-list 'lsp-language-id-configuration + '(move-mode . "move")) + + (lsp-register-client + (make-lsp-client :new-connection (lsp-stdio-connection "move-analyzer") + :activation-fn (lsp-activate-on "move") + :server-id 'move-analyzer))) +``` + +
+ +## Building & running tests + +The project uses a simple `make`-based build system for building and running +tests. Running `make test` in this directory will run the tests for each +contract. If you only want to run the tests for, say, the token bridge contract, +then you can run `make test` in the `token_bridge` directory, or run `make -C +token_bridge test` from this directory. + +Additionally, `make test-docker` runs the tests in a docker container which is +set up with all the necessary dependencies. This is the command that runs in CI. + +## Running a local validator and deploying the contracts to it + +Simply run + +```sh +worm start-validator sui +``` + +which will start a local sui validator with an RPC endpoint at `0.0.0.0:9000`. + +Once the validator is running, the contracts are ready to deploy. In the +[scripts](./scripts) directory, run + +```sh +scripts $ ./deploy.sh devnet +``` + +This will deploy the core contract and the token bridge. + +When you make a change to the contract, you can simply restart the validator and +run the deploy script again. + + + +# Implementation notes / coding practices + +In this section, we describe some of the implementation design decisions and +coding practices we converged on along the way. Note that the coding guidelines +are prescriptive rather than descriptive, and the goal is for the contracts to +ultimately follow these, but they might not during earlier development phases. + +### TODO diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/127.0.0.1-36219.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/127.0.0.1-36219.yaml new file mode 100644 index 0000000000..e489d5c3dc --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/127.0.0.1-36219.yaml @@ -0,0 +1,125 @@ +--- +protocol-key-pair: + value: avYcyVgYMXTyaUYh9IRwLK0gSzl7YF6ZQDAbrS1Bhvo= +worker-key-pair: + value: AAvfYqj1HPsXmthZ1t2Uw19vU6tdhK48YAFgkhJ7P/sV +account-key-pair: + value: ABmHnCaxw0GWzW+1MZYfTDonS1wZsO8KO37SXgm6pqc6 +network-key-pair: + value: AEpJ6PVCvnrtaxREy8UNSiDwLPPrZMh12TbgELadmAHB +db-path: /root/.sui/sui_config/authorities_db/8dcff6d15504 +network-address: /ip4/127.0.0.1/tcp/36219/http +json-rpc-address: "127.0.0.1:37179" +enable-experimental-rest-api: true +metrics-address: "127.0.0.1:44423" +admin-interface-port: 35585 +consensus-config: + address: /ip4/127.0.0.1/tcp/35107/http + db-path: /root/.sui/sui_config/consensus_db/8dcff6d15504 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/42177/http + network_admin_server: + primary_network_admin_server_port: 34745 + worker_network_admin_server_base_port: 43111 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:41551" + external-address: /ip4/127.0.0.1/udp/41551 + state-sync: + checkpoint-content-timeout-ms: 10000 +genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false +transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] +certificate-deny-config: {} +state-debug-dump-config: {} +state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false +state-archive-read-config: [] +state-snapshot-write-config: + concurrency: 0 +indexer-max-subscriptions: ~ +transaction-kv-store-read-config: + base-url: "" +jwk-fetch-interval-seconds: 3600 +zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch +authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/127.0.0.1-36853.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/127.0.0.1-36853.yaml new file mode 100644 index 0000000000..ec936e990a --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/127.0.0.1-36853.yaml @@ -0,0 +1,125 @@ +--- +protocol-key-pair: + value: OXnx3yM1C/ppgnDMx/o1d49fJs7E05kq11mXNae/O+I= +worker-key-pair: + value: AE4ZKvLhbIyoYlv0y7q7aPHyU/Jty/D1AzILgYUs4VqC +account-key-pair: + value: AEAh/lnBSwKKrazfLNz3J7DBu7W2EMuhcShk6MHJhxpT +network-key-pair: + value: AHdOWNkwAgBFMTlwVSGkhI4COGDX40frs5xOz72DHvNm +db-path: /root/.sui/sui_config/authorities_db/addeef94d898 +network-address: /ip4/127.0.0.1/tcp/36853/http +json-rpc-address: "127.0.0.1:34043" +enable-experimental-rest-api: true +metrics-address: "127.0.0.1:45007" +admin-interface-port: 36657 +consensus-config: + address: /ip4/127.0.0.1/tcp/45105/http + db-path: /root/.sui/sui_config/consensus_db/addeef94d898 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/44505/http + network_admin_server: + primary_network_admin_server_port: 45567 + worker_network_admin_server_base_port: 43075 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:37183" + external-address: /ip4/127.0.0.1/udp/37183 + state-sync: + checkpoint-content-timeout-ms: 10000 +genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false +transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] +certificate-deny-config: {} +state-debug-dump-config: {} +state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false +state-archive-read-config: [] +state-snapshot-write-config: + concurrency: 0 +indexer-max-subscriptions: ~ +transaction-kv-store-read-config: + base-url: "" +jwk-fetch-interval-seconds: 3600 +zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch +authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/127.0.0.1-39101.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/127.0.0.1-39101.yaml new file mode 100644 index 0000000000..9f5954a4d3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/127.0.0.1-39101.yaml @@ -0,0 +1,125 @@ +--- +protocol-key-pair: + value: CyNkjqNVr3HrHTH7f/NLs7u5lUHJzuPAw0PqMTD2y2s= +worker-key-pair: + value: AOuUqLZBJxwz++dkJA9sY0wvTykcCC6jSS3Jqz77IlRI +account-key-pair: + value: AEUws4dzsXHsai5hVbK1O8jWOpPAJjtzdJl32Vxvoj83 +network-key-pair: + value: ADGySwzr54kpKui4vTatL4CtV4/1ffyyHuZ6CMyzZPGI +db-path: /root/.sui/sui_config/authorities_db/b3fd5efb5c87 +network-address: /ip4/127.0.0.1/tcp/39101/http +json-rpc-address: "127.0.0.1:38815" +enable-experimental-rest-api: true +metrics-address: "127.0.0.1:32833" +admin-interface-port: 39835 +consensus-config: + address: /ip4/127.0.0.1/tcp/43831/http + db-path: /root/.sui/sui_config/consensus_db/b3fd5efb5c87 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/40195/http + network_admin_server: + primary_network_admin_server_port: 45269 + worker_network_admin_server_base_port: 39967 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:36503" + external-address: /ip4/127.0.0.1/udp/36503 + state-sync: + checkpoint-content-timeout-ms: 10000 +genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false +transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] +certificate-deny-config: {} +state-debug-dump-config: {} +state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false +state-archive-read-config: [] +state-snapshot-write-config: + concurrency: 0 +indexer-max-subscriptions: ~ +transaction-kv-store-read-config: + base-url: "" +jwk-fetch-interval-seconds: 3600 +zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch +authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/127.0.0.1-39187.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/127.0.0.1-39187.yaml new file mode 100644 index 0000000000..59b82dc21c --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/127.0.0.1-39187.yaml @@ -0,0 +1,125 @@ +--- +protocol-key-pair: + value: VTDx4HjVmRBqdqBWg2zN+zcFE20io3CrBchGy/iV1lo= +worker-key-pair: + value: ACsedxHqp9Son+iep5m4+eKM+yMc8hYyqhrDJLUucJ+G +account-key-pair: + value: AAAujq3QBAO4JNOYeKBW5dMn+8N4zE4bEHx+Bv9Y5tKr +network-key-pair: + value: AOFPA8/e6v4OpU5U0308llf51JfsxVla/pclVq9Ztajb +db-path: /root/.sui/sui_config/authorities_db/99f25ef61f80 +network-address: /ip4/127.0.0.1/tcp/39187/http +json-rpc-address: "127.0.0.1:33519" +enable-experimental-rest-api: true +metrics-address: "127.0.0.1:33765" +admin-interface-port: 33957 +consensus-config: + address: /ip4/127.0.0.1/tcp/41413/http + db-path: /root/.sui/sui_config/consensus_db/99f25ef61f80 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/35645/http + network_admin_server: + primary_network_admin_server_port: 44333 + worker_network_admin_server_base_port: 43351 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:40869" + external-address: /ip4/127.0.0.1/udp/40869 + state-sync: + checkpoint-content-timeout-ms: 10000 +genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false +transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] +certificate-deny-config: {} +state-debug-dump-config: {} +state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false +state-archive-read-config: [] +state-snapshot-write-config: + concurrency: 0 +indexer-max-subscriptions: ~ +transaction-kv-store-read-config: + base-url: "" +jwk-fetch-interval-seconds: 3600 +zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch +authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/client.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/client.yaml new file mode 100644 index 0000000000..c9302468b5 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/client.yaml @@ -0,0 +1,12 @@ +--- +keystore: + File: /root/.sui/sui_config/sui.keystore +envs: + - alias: localnet + rpc: "http://0.0.0.0:9000" + ws: ~ + - alias: devnet + rpc: "https://fullnode.devnet.sui.io:443" + ws: ~ +active_env: localnet +active_address: ~ diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/fullnode.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/fullnode.yaml new file mode 100644 index 0000000000..c89b027b28 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/fullnode.yaml @@ -0,0 +1,107 @@ +--- +protocol-key-pair: + value: JowI/tZTaWZUl32KFepfJUNYnU+0BklUpSPuKEeFcm0= +worker-key-pair: + value: AGIw3mefR34IhvBwYUBAilZJ8Hl8IwJr/BeI1MYwalsR +account-key-pair: + value: AImtWzJTcrcQL00HzJqQy4y0i+XIfZIbK/rUyyaq0f56 +network-key-pair: + value: AGeBrH0F+ehSceQ1zOUs8r2Z2z3iEJ/3RlW0/dN+/dj0 +db-path: full_node_db/full_node_db/b10469f99d8b +network-address: /ip4/127.0.0.1/tcp/42193/http +json-rpc-address: "0.0.0.0:9000" +enable-experimental-rest-api: true +metrics-address: "127.0.0.1:38381" +admin-interface-port: 46743 +enable-event-processing: true +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: ~ +p2p-config: + listen-address: "127.0.0.1:35253" + external-address: /ip4/127.0.0.1/udp/35253 + seed-peers: + - peer-id: e8064daeac1c8801ce3e594cae452f11b453ce616c81974c7b3395d9992a6b37 + address: /ip4/127.0.0.1/udp/40869 + - peer-id: edca3a352dc8953587ffd265df885351c842689252c141960afa0870dfee7439 + address: /ip4/127.0.0.1/udp/41551 + - peer-id: d5e061082e23e6bbe75d1f0fcfcb982967f84c700e2c558482990dde14d8fd1b + address: /ip4/127.0.0.1/udp/37183 + - peer-id: 0395788680d90c7debf0671c18a608018d5800322459c7bc35ce0ee49cf6eeba + address: /ip4/127.0.0.1/udp/36503 + state-sync: + checkpoint-content-timeout-ms: 10000 +genesis: + genesis: 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 +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: true + enable-deep-per-tx-sui-conservation-check: true + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: true + force-disable-state-consistency-check: false + enable-secondary-index-checks: false +transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] +certificate-deny-config: {} +state-debug-dump-config: {} +state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false +state-archive-read-config: [] +state-snapshot-write-config: + concurrency: 0 +indexer-max-subscriptions: ~ +transaction-kv-store-read-config: + base-url: "" +jwk-fetch-interval-seconds: 3600 +zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch +authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/genesis.blob b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/genesis.blob new file mode 100644 index 0000000000..5d1cb997ea Binary files /dev/null and b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/genesis.blob differ diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/genesis_config b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/genesis_config new file mode 100644 index 0000000000..aeb16458fa --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/genesis_config @@ -0,0 +1,55 @@ +--- +ssfn_config_info: ~ +validator_config_info: ~ +parameters: + chain_start_timestamp_ms: 1709486339140 + protocol_version: 36 + allow_insertion_of_extra_objects: true + epoch_duration_ms: 86400000 + stake_subsidy_start_epoch: 0 + stake_subsidy_initial_distribution_amount: 1000000000000000 + stake_subsidy_period_length: 10 + stake_subsidy_decrease_rate: 1000 +accounts: + - address: "0x2e425dd30f43ff1d59547322839cfc4b8fbaae54d72075181ebd7388b644fdbe" + gas_amounts: + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - address: "0x8a8bb058d6c86aa175566c9e2d19278dd22ed9fecdda8fb486018f93a0629bb5" + gas_amounts: + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - address: "0xa0f33ce147ecae789f535c64634851724284dd618a529672702b991a5f7bf816" + gas_amounts: + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - address: "0xbd00a48078c0513a5f9a0d1c9352cd5c23a0e0cf3e6a82673cdae857cd00021e" + gas_amounts: + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - address: "0xfd5f84cf9285f2b206e03727224b9daffa6092661b840d92434751792010b7de" + gas_amounts: + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - address: "0xed867315e3f7c83ae82e6d5858b6a6cc57c291fd84f7509646ebc8162169cf96" + gas_amounts: + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 + - 30000000000000000 diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/network.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/network.yaml new file mode 100644 index 0000000000..c6206fc155 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/devnet/network.yaml @@ -0,0 +1,500 @@ +--- +validator_configs: + - protocol-key-pair: + value: VTDx4HjVmRBqdqBWg2zN+zcFE20io3CrBchGy/iV1lo= + worker-key-pair: + value: ACsedxHqp9Son+iep5m4+eKM+yMc8hYyqhrDJLUucJ+G + account-key-pair: + value: AAAujq3QBAO4JNOYeKBW5dMn+8N4zE4bEHx+Bv9Y5tKr + network-key-pair: + value: AOFPA8/e6v4OpU5U0308llf51JfsxVla/pclVq9Ztajb + db-path: /root/.sui/sui_config/authorities_db/99f25ef61f80 + network-address: /ip4/127.0.0.1/tcp/39187/http + json-rpc-address: "127.0.0.1:33519" + enable-experimental-rest-api: true + metrics-address: "127.0.0.1:33765" + admin-interface-port: 33957 + consensus-config: + address: /ip4/127.0.0.1/tcp/41413/http + db-path: /root/.sui/sui_config/consensus_db/99f25ef61f80 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/35645/http + network_admin_server: + primary_network_admin_server_port: 44333 + worker_network_admin_server_base_port: 43351 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:40869" + external-address: /ip4/127.0.0.1/udp/40869 + state-sync: + checkpoint-content-timeout-ms: 10000 + genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false + transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] + certificate-deny-config: {} + state-debug-dump-config: {} + state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false + state-archive-read-config: [] + state-snapshot-write-config: + concurrency: 0 + indexer-max-subscriptions: ~ + transaction-kv-store-read-config: + base-url: "" + jwk-fetch-interval-seconds: 3600 + zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch + authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 + - protocol-key-pair: + value: avYcyVgYMXTyaUYh9IRwLK0gSzl7YF6ZQDAbrS1Bhvo= + worker-key-pair: + value: AAvfYqj1HPsXmthZ1t2Uw19vU6tdhK48YAFgkhJ7P/sV + account-key-pair: + value: ABmHnCaxw0GWzW+1MZYfTDonS1wZsO8KO37SXgm6pqc6 + network-key-pair: + value: AEpJ6PVCvnrtaxREy8UNSiDwLPPrZMh12TbgELadmAHB + db-path: /root/.sui/sui_config/authorities_db/8dcff6d15504 + network-address: /ip4/127.0.0.1/tcp/36219/http + json-rpc-address: "127.0.0.1:37179" + enable-experimental-rest-api: true + metrics-address: "127.0.0.1:44423" + admin-interface-port: 35585 + consensus-config: + address: /ip4/127.0.0.1/tcp/35107/http + db-path: /root/.sui/sui_config/consensus_db/8dcff6d15504 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/42177/http + network_admin_server: + primary_network_admin_server_port: 34745 + worker_network_admin_server_base_port: 43111 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:41551" + external-address: /ip4/127.0.0.1/udp/41551 + state-sync: + checkpoint-content-timeout-ms: 10000 + genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false + transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] + certificate-deny-config: {} + state-debug-dump-config: {} + state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false + state-archive-read-config: [] + state-snapshot-write-config: + concurrency: 0 + indexer-max-subscriptions: ~ + transaction-kv-store-read-config: + base-url: "" + jwk-fetch-interval-seconds: 3600 + zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch + authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 + - protocol-key-pair: + value: OXnx3yM1C/ppgnDMx/o1d49fJs7E05kq11mXNae/O+I= + worker-key-pair: + value: AE4ZKvLhbIyoYlv0y7q7aPHyU/Jty/D1AzILgYUs4VqC + account-key-pair: + value: AEAh/lnBSwKKrazfLNz3J7DBu7W2EMuhcShk6MHJhxpT + network-key-pair: + value: AHdOWNkwAgBFMTlwVSGkhI4COGDX40frs5xOz72DHvNm + db-path: /root/.sui/sui_config/authorities_db/addeef94d898 + network-address: /ip4/127.0.0.1/tcp/36853/http + json-rpc-address: "127.0.0.1:34043" + enable-experimental-rest-api: true + metrics-address: "127.0.0.1:45007" + admin-interface-port: 36657 + consensus-config: + address: /ip4/127.0.0.1/tcp/45105/http + db-path: /root/.sui/sui_config/consensus_db/addeef94d898 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/44505/http + network_admin_server: + primary_network_admin_server_port: 45567 + worker_network_admin_server_base_port: 43075 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:37183" + external-address: /ip4/127.0.0.1/udp/37183 + state-sync: + checkpoint-content-timeout-ms: 10000 + genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false + transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] + certificate-deny-config: {} + state-debug-dump-config: {} + state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false + state-archive-read-config: [] + state-snapshot-write-config: + concurrency: 0 + indexer-max-subscriptions: ~ + transaction-kv-store-read-config: + base-url: "" + jwk-fetch-interval-seconds: 3600 + zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch + authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 + - protocol-key-pair: + value: CyNkjqNVr3HrHTH7f/NLs7u5lUHJzuPAw0PqMTD2y2s= + worker-key-pair: + value: AOuUqLZBJxwz++dkJA9sY0wvTykcCC6jSS3Jqz77IlRI + account-key-pair: + value: AEUws4dzsXHsai5hVbK1O8jWOpPAJjtzdJl32Vxvoj83 + network-key-pair: + value: ADGySwzr54kpKui4vTatL4CtV4/1ffyyHuZ6CMyzZPGI + db-path: /root/.sui/sui_config/authorities_db/b3fd5efb5c87 + network-address: /ip4/127.0.0.1/tcp/39101/http + json-rpc-address: "127.0.0.1:38815" + enable-experimental-rest-api: true + metrics-address: "127.0.0.1:32833" + admin-interface-port: 39835 + consensus-config: + address: /ip4/127.0.0.1/tcp/43831/http + db-path: /root/.sui/sui_config/consensus_db/b3fd5efb5c87 + internal-worker-address: ~ + max-pending-transactions: ~ + max-submit-position: ~ + submit-delay-step-override-millis: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 1000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 5000000 + max_batch_delay: 100ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/40195/http + network_admin_server: + primary_network_admin_server_port: 45269 + worker_network_admin_server_base_port: 39967 + anemo: + send_certificate_rate_limit: ~ + report_batch_rate_limit: ~ + request_batches_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:36503" + external-address: /ip4/127.0.0.1/udp/36503 + state-sync: + checkpoint-content-timeout-ms: 10000 + genesis: + genesis-file-location: /root/.sui/sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 0 + max-checkpoints-in-batch: 10 + max-transactions-in-batch: 1000 + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-secondary-index-checks: false + transaction-deny-config: + package-publish-disabled: false + package-upgrade-disabled: false + shared-object-disabled: false + user-transaction-disabled: false + receiving-objects-disabled: false + zklogin-sig-disabled: false + zklogin-disabled-providers: [] + certificate-deny-config: {} + state-debug-dump-config: {} + state-archive-write-config: + concurrency: 0 + use-for-pruning-watermark: false + state-archive-read-config: [] + state-snapshot-write-config: + concurrency: 0 + indexer-max-subscriptions: ~ + transaction-kv-store-read-config: + base-url: "" + jwk-fetch-interval-seconds: 3600 + zklogin-oauth-providers: + Mainnet: + - Facebook + - Google + - Twitch + Testnet: + - Facebook + - Google + - Twitch + Unknown: + - Apple + - Facebook + - Google + - Kakao + - Slack + - Twitch + authority-overload-config: + max-txn-age-in-queue: + secs: 1 + nanos: 0 + overload-monitor-interval: + secs: 10 + nanos: 0 + execution-queue-latency-soft-limit: + secs: 1 + nanos: 0 + execution-queue-latency-hard-limit: + secs: 10 + nanos: 0 + max-load-shedding-percentage: 95 + min-load-shedding-percentage-above-hard-limit: 50 + safe-transaction-ready-rate: 100 +account_keys: [] +genesis: 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 diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/.gitignore b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/.gitignore new file mode 100644 index 0000000000..378eac25d3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/.gitignore @@ -0,0 +1 @@ +build diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/Makefile b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/Makefile new file mode 100644 index 0000000000..9b862faf0a --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/Makefile @@ -0,0 +1,15 @@ +.PHONY: all clean test check + +all: check + +.PHONY: clean +clean: + rm -rf build + +.PHONY: check +check: + sui move build -d + +.PHONY: test +test: check + sui move test -d diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/Move.devnet.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/Move.devnet.toml new file mode 100644 index 0000000000..b505feb87d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/Move.devnet.toml @@ -0,0 +1,17 @@ +[package] +name = "Coins" +version = "0.1.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../../wormhole" + +[dependencies.TokenBridge] +local = "../../token_bridge" + +[addresses] +coins = "_" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/Move.lock b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/Move.lock new file mode 100644 index 0000000000..26f89cf4a1 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/Move.lock @@ -0,0 +1,52 @@ +# @generated by Move, please check-in and do not edit manually. + +[move] +version = 0 +manifest_digest = "F1027436A2346E82F07F1149F91C26F61778F611858CEA83F9D22BDEF50A7FD8" +deps_digest = "397E6A9F7A624706DBDFEE056CE88391A15876868FD18A88504DA74EB458D697" + +dependencies = [ + { name = "Sui" }, +] + +dev-dependencies = [ + { name = "TokenBridge" }, + { name = "Wormhole" }, +] + +[[move.package]] +name = "MoveStdlib" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/move-stdlib" } + +[[move.package]] +name = "Sui" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/sui-framework" } + +dependencies = [ + { name = "MoveStdlib" }, +] + +[[move.package]] +name = "TokenBridge" +source = { local = "../../token_bridge" } + +dependencies = [ + { name = "Sui" }, +] + +dev-dependencies = [ + { name = "Wormhole" }, +] + +[[move.package]] +name = "Wormhole" +source = { local = "../../wormhole" } + +dependencies = [ + { name = "Sui" }, +] + +[move.toolchain-version] +compiler-version = "1.19.0" +edition = "legacy" +flavor = "sui" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/Move.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/Move.toml new file mode 100644 index 0000000000..ac052a42c4 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/Move.toml @@ -0,0 +1,28 @@ +[package] +name = "Coins" +version = "0.1.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../../wormhole" + +[dependencies.TokenBridge] +local = "../../token_bridge" + +[addresses] +coins = "_" + +[dev-dependencies.Wormhole] +local = "../../wormhole" + +[dev-dependencies.TokenBridge] +local = "../../token_bridge" + +[dev-addresses] +wormhole = "0x100" +token_bridge = "0x200" +coins = "0x20c" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/sources/coin.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/sources/coin.move new file mode 100644 index 0000000000..108ebe52d6 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/sources/coin.move @@ -0,0 +1,210 @@ +// Example wrapped coin for testing purposes + +#[test_only] +module coins::coin { + use sui::object::{Self}; + use sui::package::{Self}; + use sui::transfer::{Self}; + use sui::tx_context::{Self, TxContext}; + + use token_bridge::create_wrapped::{Self}; + + struct COIN has drop {} + + fun init(witness: COIN, ctx: &mut TxContext) { + use token_bridge::version_control::{V__0_2_0 as V__CURRENT}; + + transfer::public_transfer( + create_wrapped::prepare_registration( + witness, + // TODO: create a version of this for each decimal to be used + 8, + ctx + ), + tx_context::sender(ctx) + ); + } + + #[test_only] + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_test_only(ctx: &mut TxContext) { + init(COIN {}, ctx); + + // This will be created and sent to the transaction sender + // automatically when the contract is published. + transfer::public_transfer( + package::test_publish(object::id_from_address(@coins), ctx), + tx_context::sender(ctx) + ); + } +} + +#[test_only] +module coins::coin_tests { + use sui::coin::{Self}; + use sui::package::{UpgradeCap}; + use sui::test_scenario::{Self}; + use token_bridge::create_wrapped::{Self, WrappedAssetSetup}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + register_dummy_emitter, + return_state, + set_up_wormhole_and_token_bridge, + take_state, + two_people + }; + use token_bridge::token_registry::{Self}; + use token_bridge::vaa::{Self}; + use token_bridge::wrapped_asset::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::external_address::{Self}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + use token_bridge::version_control::{V__0_2_0 as V__CURRENT}; + + use coins::coin::{COIN}; + +// +------------------------------------------------------------------------------+ +// | Wormhole VAA v1 | nonce: 1 | time: 1 | +// | guardian set #0 | #22080291 | consistency: 0 | +// |------------------------------------------------------------------------------| +// | Signature: | +// | #0: 80366065746148420220f25a6275097370e8db40984529a6676b7a5fc9fe... | +// |------------------------------------------------------------------------------| +// | Emitter: 0x00000000000000000000000000000000deadbeef (Ethereum) | +// |==============================================================================| +// | Token attestation | +// | decimals: 12 | +// | Token: 0x00000000000000000000000000000000beefface (Ethereum) | +// | Symbol: BEEF | +// | Name: Beef face Token | +// +------------------------------------------------------------------------------+ + const VAA: vector = + x"0100000000010080366065746148420220f25a6275097370e8db40984529a6676b7a5fc9feb11755ec49ca626b858ddfde88d15601f85ab7683c5f161413b0412143241c700aff010000000100000001000200000000000000000000000000000000000000000000000000000000deadbeef000000000150eb23000200000000000000000000000000000000000000000000000000000000beefface00020c424545460000000000000000000000000000000000000000000000000000000042656566206661636520546f6b656e0000000000000000000000000000000000"; + +// +------------------------------------------------------------------------------+ +// | Wormhole VAA v1 | nonce: 69 | time: 0 | +// | guardian set #0 | #1 | consistency: 15 | +// |------------------------------------------------------------------------------| +// | Signature: | +// | #0: b0571650590e147fce4eb60105e0463522c1244a97bd5dcb365d3e7bc7f3... | +// |------------------------------------------------------------------------------| +// | Emitter: 0x00000000000000000000000000000000deadbeef (Ethereum) | +// |==============================================================================| +// | Token attestation | +// | decimals: 12 | +// | Token: 0x00000000000000000000000000000000beefface (Ethereum) | +// | Symbol: BEEF??? and profit | +// | Name: Beef face Token??? and profit | +// +------------------------------------------------------------------------------+ + const UPDATED_VAA: vector = + x"0100000000010062f4dcd21bbbc4af8b8baaa2da3a0b168efc4c975de5b828c7a3c710b67a0a0d476d10a74aba7a7867866daf97d1372d8e6ee62ccc5ae522e3e603c67fa23787000000000000000045000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f0200000000000000000000000000000000000000000000000000000000beefface00020c424545463f3f3f20616e642070726f666974000000000000000000000000000042656566206661636520546f6b656e3f3f3f20616e642070726f666974000000"; + + + #[test] + public fun test_complete_and_update_attestation() { + let (caller, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. Make sure `coin_deployer` receives + // `WrappedAssetSetup`. + test_scenario::next_tx(scenario, coin_deployer); + + // Publish coin. + coins::coin::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, coin_deployer); + + let wrapped_asset_setup = + test_scenario::take_from_address>( + scenario, + coin_deployer + ); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + let coin_meta = test_scenario::take_shared(scenario); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + wrapped_asset_setup, + test_scenario::take_from_address( + scenario, + coin_deployer + ), + msg + ); + + // Check registry. + { + let verified = state::verified_asset(&token_bridge_state); + assert!(token_bridge::token_registry::is_wrapped(&verified), 0); + + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == 0, 0); + + // Decimals are capped for this wrapped asset. + assert!(coin::get_decimals(&coin_meta) == 8, 0); + + // Check metadata against asset metadata. + let info = wrapped_asset::info(asset); + assert!(wrapped_asset::token_chain(info) == 2, 0); + assert!(wrapped_asset::token_address(info) == external_address::new(bytes32::from_bytes(x"00000000000000000000000000000000beefface")), 0); + assert!( + wrapped_asset::native_decimals(info) == 12, + 0 + ); + assert!(coin::get_symbol(&coin_meta) == std::ascii::string(b"BEEF"), 0); + assert!(coin::get_name(&coin_meta) == std::string::utf8(b"Beef face Token"), 0); + }; + + let verified_vaa = + parse_and_verify_vaa(scenario, UPDATED_VAA); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Now update metadata. + create_wrapped::update_attestation(&mut token_bridge_state, &mut coin_meta, msg); + + // Check updated name and symbol. + assert!( + coin::get_name(&coin_meta) == std::string::utf8(b"Beef face Token??? and profit"), + 0 + ); + assert!( + coin::get_symbol(&coin_meta) == std::ascii::string(b"BEEF??? and profit"), + 0 + ); + + // Clean up. + return_state(token_bridge_state); + test_scenario::return_shared(coin_meta); + + + // Done. + test_scenario::end(my_scenario); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/sources/coin_10.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/sources/coin_10.move new file mode 100644 index 0000000000..2c98b87936 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/sources/coin_10.move @@ -0,0 +1,72 @@ +module coins::coin_10 { + use std::option; + use sui::coin::{Self, TreasuryCap, CoinMetadata}; + use sui::transfer; + use sui::tx_context::{Self, TxContext}; + + /// The type identifier of coin. The coin will have a type + /// tag of kind: `Coin` + /// Make sure that the name of the type matches the module's name. + struct COIN_10 has drop {} + + /// Module initializer is called once on module publish. A treasury + /// cap is sent to the publisher, who then controls minting and burning + fun init(witness: COIN_10, ctx: &mut TxContext) { + let (treasury, metadata) = create_coin(witness, ctx); + transfer::public_freeze_object(metadata); + transfer::public_transfer(treasury, tx_context::sender(ctx)); + } + + fun create_coin( + witness: COIN_10, + ctx: &mut TxContext + ): (TreasuryCap, CoinMetadata) { + coin::create_currency( + witness, + 10, // decimals + b"COIN_10", // symbol + b"10-Decimal Coin", // name + b"", // description + option::none(), // icon_url + ctx + ) + } + + #[test_only] + public fun create_coin_test_only( + ctx: &mut TxContext + ): (TreasuryCap, CoinMetadata) { + create_coin(COIN_10 {}, ctx) + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_10 {}, ctx) + } +} + +#[test_only] +module coins::coin_10_tests { + use sui::test_scenario::{Self}; + + use coins::coin_10::{Self}; + + #[test] + public fun init_test() { + let my_scenario = test_scenario::begin(@0x0); + let scenario = &mut my_scenario; + let creator = @0xDEADBEEF; + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Init. + coin_10::init_test_only(test_scenario::ctx(scenario)); + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Done. + test_scenario::end(my_scenario); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/sources/coin_8.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/sources/coin_8.move new file mode 100644 index 0000000000..0edd761603 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/coins/sources/coin_8.move @@ -0,0 +1,72 @@ +module coins::coin_8 { + use std::option::{Self}; + use sui::coin::{Self, TreasuryCap, CoinMetadata}; + use sui::transfer::{Self}; + use sui::tx_context::{Self, TxContext}; + + /// The type identifier of coin. The coin will have a type + /// tag of kind: `Coin` + /// Make sure that the name of the type matches the module's name. + struct COIN_8 has drop {} + + /// Module initializer is called once on module publish. A treasury + /// cap is sent to the publisher, who then controls minting and burning + fun init(witness: COIN_8, ctx: &mut TxContext) { + let (treasury, metadata) = create_coin(witness, ctx); + transfer::public_freeze_object(metadata); + transfer::public_transfer(treasury, tx_context::sender(ctx)); + } + + fun create_coin( + witness: COIN_8, + ctx: &mut TxContext + ): (TreasuryCap, CoinMetadata) { + coin::create_currency( + witness, + 8, // decimals + b"COIN_8", // symbol + b"8-Decimal Coin", // name + b"", // description + option::none(), // icon_url + ctx + ) + } + + #[test_only] + public fun create_coin_test_only( + ctx: &mut TxContext + ): (TreasuryCap, CoinMetadata) { + create_coin(COIN_8 {}, ctx) + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_8 {}, ctx) + } +} + +#[test_only] +module coins::coin_8_tests { + use sui::test_scenario::{Self}; + + use coins::coin_8::{Self}; + + #[test] + public fun init_test() { + let my_scenario = test_scenario::begin(@0x0); + let scenario = &mut my_scenario; + let creator = @0xDEADBEEF; + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Init. + coin_8::init_test_only(test_scenario::ctx(scenario)); + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Done. + test_scenario::end(my_scenario); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/Makefile b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/Makefile new file mode 100644 index 0000000000..210a28de7a --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/Makefile @@ -0,0 +1,20 @@ +-include ../../../Makefile.help + +.PHONY: artifacts +artifacts: clean + +.PHONY: clean +# Clean build artifacts +clean: + rm -rf build + +.PHONY: build +# Build contract +build: + sui move build + +.PHONY: test +# Run tests +test: + sui move build -d || exit $? + sui move test -t 1 diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/Move.devnet.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/Move.devnet.toml new file mode 100644 index 0000000000..d9363b2554 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/Move.devnet.toml @@ -0,0 +1,14 @@ +[package] +name = "CoreMessages" +version = "1.0.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../../wormhole" + +[addresses] +core_messages = "_" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/Move.lock b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/Move.lock new file mode 100644 index 0000000000..9bddcd1268 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/Move.lock @@ -0,0 +1,39 @@ +# @generated by Move, please check-in and do not edit manually. + +[move] +version = 0 +manifest_digest = "E0D2B32F0A5B6F9A76311FD7A68260A698BD9ECCEAF95A779183CB374EC933FB" +deps_digest = "060AD7E57DFB13104F21BE5F5C3759D03F0553FC3229247D9A7A6B45F50D03A3" + +dependencies = [ + { name = "Sui" }, +] + +dev-dependencies = [ + { name = "Wormhole" }, +] + +[[move.package]] +name = "MoveStdlib" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/move-stdlib" } + +[[move.package]] +name = "Sui" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/sui-framework" } + +dependencies = [ + { name = "MoveStdlib" }, +] + +[[move.package]] +name = "Wormhole" +source = { local = "../../wormhole" } + +dependencies = [ + { name = "Sui" }, +] + +[move.toolchain-version] +compiler-version = "1.19.0" +edition = "legacy" +flavor = "sui" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/Move.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/Move.toml new file mode 100644 index 0000000000..38872b17dc --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/Move.toml @@ -0,0 +1,21 @@ +[package] +name = "CoreMessages" +version = "1.0.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../../wormhole" + +[addresses] +core_messages = "_" + +[dev-dependencies.Wormhole] +local = "../../wormhole" + +[dev-addresses] +wormhole = "0x100" +core_messages = "0x169" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/sources/sender.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/sources/sender.move new file mode 100644 index 0000000000..960c6355c3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/core_messages/sources/sender.move @@ -0,0 +1,149 @@ +/// A simple contracts that demonstrates how to send messages with wormhole. +module core_messages::sender { + use sui::clock::{Clock}; + use sui::coin::{Self}; + use sui::object::{Self, UID}; + use sui::transfer::{Self}; + use sui::tx_context::{TxContext}; + use wormhole::emitter::{Self, EmitterCap}; + use wormhole::state::{State as WormholeState}; + + struct State has key, store { + id: UID, + emitter_cap: EmitterCap, + } + + /// Register ourselves as a wormhole emitter. This gives back an + /// `EmitterCap` which will be required to send messages through + /// wormhole. + public fun init_with_params( + wormhole_state: &WormholeState, + ctx: &mut TxContext + ) { + transfer::share_object( + State { + id: object::new(ctx), + emitter_cap: emitter::new(wormhole_state, ctx) + } + ); + } + + public fun send_message_entry( + state: &mut State, + wormhole_state: &mut WormholeState, + payload: vector, + the_clock: &Clock, + ctx: &mut TxContext + ) { + send_message( + state, + wormhole_state, + payload, + the_clock, + ctx + ); + } + + /// NOTE: This is NOT the proper way of using the `prepare_message` and + /// `publish_message` workflow. This example app is meant for testing for + /// observing Wormhole messages via the guardian. + /// + /// See `publish_message` module for more info. + public fun send_message( + state: &mut State, + wormhole_state: &mut WormholeState, + payload: vector, + the_clock: &Clock, + ctx: &mut TxContext + ): u64 { + use wormhole::publish_message::{prepare_message, publish_message}; + + // NOTE AGAIN: Integrators should NEVER call this within their contract. + publish_message( + wormhole_state, + coin::zero(ctx), + prepare_message( + &mut state.emitter_cap, + 0, // Set nonce to 0, intended for batch VAAs. + payload + ), + the_clock + ) + } +} + +#[test_only] +module core_messages::sender_test { + use sui::test_scenario::{Self}; + use wormhole::wormhole_scenario::{ + return_clock, + return_state, + set_up_wormhole, + take_clock, + take_state, + two_people, + }; + + use core_messages::sender::{ + State, + init_with_params, + send_message, + }; + + #[test] + public fun test_send_message() { + let (user, admin) = two_people(); + let my_scenario = test_scenario::begin(admin); + let scenario = &mut my_scenario; + + // Initialize Wormhole. + let wormhole_message_fee = 0; + set_up_wormhole(scenario, wormhole_message_fee); + + // Initialize sender module. + test_scenario::next_tx(scenario, admin); + { + let wormhole_state = take_state(scenario); + init_with_params(&wormhole_state, test_scenario::ctx(scenario)); + return_state(wormhole_state); + }; + + // Send message as an ordinary user. + test_scenario::next_tx(scenario, user); + { + let state = test_scenario::take_shared(scenario); + let wormhole_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let first_message_sequence = send_message( + &mut state, + &mut wormhole_state, + b"Hello", + &the_clock, + test_scenario::ctx(scenario) + ); + assert!(first_message_sequence == 0, 0); + + let second_message_sequence = send_message( + &mut state, + &mut wormhole_state, + b"World", + &the_clock, + test_scenario::ctx(scenario) + ); + assert!(second_message_sequence == 1, 0); + + // Clean up. + test_scenario::return_shared(state); + return_state(wormhole_state); + return_clock(the_clock); + }; + + // Check effects. + let effects = test_scenario::next_tx(scenario, user); + assert!(test_scenario::num_user_events(&effects) == 2, 0); + + // End test. + test_scenario::end(my_scenario); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/templates/README.md b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/templates/README.md new file mode 100644 index 0000000000..41a8dbd907 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/templates/README.md @@ -0,0 +1,3 @@ +# Templates + +This directory contains templates for Sui contracts. These templates aren't fully functional contracts and require substitution of variables prior to deployment. For example, the `wrapped_coin` template requires the version control struct name as well as the decimals of the wrapped token. diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/templates/wrapped_coin/Move.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/templates/wrapped_coin/Move.toml new file mode 100644 index 0000000000..0c25220b1d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/templates/wrapped_coin/Move.toml @@ -0,0 +1,19 @@ +[package] +name = "WrappedCoin" +version = "0.0.1" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../../wormhole" + +[dependencies.TokenBridge] +local = "../../token_bridge" + +[addresses] +wormhole = "_" +token_bridge = "_" +wrapped_coin = "0x0" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/templates/wrapped_coin/sources/coin.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/templates/wrapped_coin/sources/coin.move new file mode 100644 index 0000000000..313b9ba919 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/examples/templates/wrapped_coin/sources/coin.move @@ -0,0 +1,21 @@ +module wrapped_coin::coin { + use sui::transfer::{Self}; + use sui::tx_context::{Self, TxContext}; + + use token_bridge::create_wrapped::{Self}; + + struct COIN has drop {} + + fun init(witness: COIN, ctx: &mut TxContext) { + use token_bridge::version_control::{{{VERSION}}}; + + transfer::public_transfer( + create_wrapped::prepare_registration( + witness, + {{DECIMALS}}, + ctx + ), + tx_context::sender(ctx) + ); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/deploy.sh b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/deploy.sh new file mode 100755 index 0000000000..d572f8cbf0 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/deploy.sh @@ -0,0 +1,119 @@ +#!/usr/bin/env bash + +set -euo pipefail + +# Help message +function usage() { +cat <&2 +Deploy and initialize Sui core bridge and token bridge contracts to the +specified network. Additionally deploys an example messaging contract in +devnet. + + Usage: $(basename "$0") [options] + + Positional args: + Network to deploy to (devnet, testnet, mainnet) + + Options: + -k, --private-key Use given key to sign transactions + -h, --help Show this help message +EOF +exit 1 +} + +# If positional args are missing, print help message and exit +if [ $# -lt 1 ]; then + usage +fi + +# Default values +PRIVATE_KEY_ARG= + +# Set network +NETWORK=$1 || usage +shift + +# Set guardian address +if [ "$NETWORK" = mainnet ]; then + echo "Mainnet not supported yet" + exit 1 +elif [ "$NETWORK" = testnet ]; then + echo "Testnet not supported yet" + exit 1 +elif [ "$NETWORK" = devnet ]; then + GUARDIAN_ADDR=befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe +else + usage +fi + +# Parse short/long flags +while [[ $# -gt 0 ]]; do + case "$1" in + -k|--private-key) + if [[ ! -z "$2" ]]; then + PRIVATE_KEY_ARG="-k $2" + fi + shift 2 + ;; + -h|--help) + usage + exit 0 + ;; + *) + echo "Unknown option: $1" + usage + exit 1 + ;; + esac +done + +# Assumes this script is in a sibling directory to contract dirs +DIRNAME=$(dirname "$0") +WORMHOLE_PATH=$(realpath "$DIRNAME"/../wormhole) +TOKEN_BRIDGE_PATH=$(realpath "$DIRNAME"/../token_bridge) +EXAMPLE_APP_PATH=$(realpath "$DIRNAME"/../examples/core_messages) +EXAMPLE_COIN_PATH=$(realpath "$DIRNAME"/../examples/coins) + +echo -e "[1/4] Publishing core bridge contracts..." +WORMHOLE_PUBLISH_OUTPUT=$($(echo worm sui deploy "$WORMHOLE_PATH" -n "$NETWORK" "$PRIVATE_KEY_ARG")) +echo "$WORMHOLE_PUBLISH_OUTPUT" + +echo -e "\n[2/4] Initializing core bridge..." +WORMHOLE_PACKAGE_ID=$(echo "$WORMHOLE_PUBLISH_OUTPUT" | grep -oP 'Published to +\K.*') +WORMHOLE_INIT_OUTPUT=$($(echo worm sui init-wormhole -n "$NETWORK" --initial-guardian "$GUARDIAN_ADDR" -p "$WORMHOLE_PACKAGE_ID" "$PRIVATE_KEY_ARG")) +WORMHOLE_STATE_OBJECT_ID=$(echo "$WORMHOLE_INIT_OUTPUT" | grep -oP 'Wormhole state object ID +\K.*') +echo "$WORMHOLE_INIT_OUTPUT" + +echo -e "\n[3/4] Publishing token bridge contracts..." +TOKEN_BRIDGE_PUBLISH_OUTPUT=$($(echo worm sui deploy "$TOKEN_BRIDGE_PATH" -n "$NETWORK" "$PRIVATE_KEY_ARG")) +echo "$TOKEN_BRIDGE_PUBLISH_OUTPUT" + +echo -e "\n[4/4] Initializing token bridge..." +TOKEN_BRIDGE_PACKAGE_ID=$(echo "$TOKEN_BRIDGE_PUBLISH_OUTPUT" | grep -oP 'Published to +\K.*') +TOKEN_BRIDGE_INIT_OUTPUT=$($(echo worm sui init-token-bridge -n "$NETWORK" -p "$TOKEN_BRIDGE_PACKAGE_ID" -w "$WORMHOLE_STATE_OBJECT_ID" "$PRIVATE_KEY_ARG")) +TOKEN_BRIDGE_STATE_OBJECT_ID=$(echo "$TOKEN_BRIDGE_INIT_OUTPUT" | grep -oP 'Token bridge state object ID +\K.*') +echo "$TOKEN_BRIDGE_INIT_OUTPUT" + +if [ "$NETWORK" = devnet ]; then + echo -e "\n[+1/2] Deploying and initializing example app..." + EXAMPLE_APP_PUBLISH_OUTPUT=$($(echo worm sui deploy "$EXAMPLE_APP_PATH" -n "$NETWORK" "$PRIVATE_KEY_ARG")) + EXAMPLE_APP_PACKAGE_ID=$(echo "$EXAMPLE_APP_PUBLISH_OUTPUT" | grep -oP 'Published to +\K.*') + echo "$EXAMPLE_APP_PUBLISH_OUTPUT" + + EXAMPLE_INIT_OUTPUT=$($(echo worm sui init-example-message-app -n "$NETWORK" -p "$EXAMPLE_APP_PACKAGE_ID" -w "$WORMHOLE_STATE_OBJECT_ID" "$PRIVATE_KEY_ARG")) + EXAMPLE_APP_STATE_OBJECT_ID=$(echo "$EXAMPLE_INIT_OUTPUT" | grep -oP 'Example app state object ID +\K.*') + echo "$EXAMPLE_INIT_OUTPUT" + + echo -e "\n[+2/2] Deploying example coins..." + EXAMPLE_COIN_PUBLISH_OUTPUT=$($(echo worm sui deploy "$EXAMPLE_COIN_PATH" -n "$NETWORK" "$PRIVATE_KEY_ARG")) + echo "$EXAMPLE_COIN_PUBLISH_OUTPUT" + + echo -e "\nWormhole package ID: $WORMHOLE_PACKAGE_ID" + echo "Token bridge package ID: $TOKEN_BRIDGE_PACKAGE_ID" + echo "Wormhole state object ID: $WORMHOLE_STATE_OBJECT_ID" + echo "Token bridge state object ID: $TOKEN_BRIDGE_STATE_OBJECT_ID" + + echo -e "\nPublish message command:" worm sui publish-example-message -n devnet -p "$EXAMPLE_APP_PACKAGE_ID" -s "$EXAMPLE_APP_STATE_OBJECT_ID" -w "$WORMHOLE_STATE_OBJECT_ID" -m "hello" "$PRIVATE_KEY_ARG" +fi + +echo -e "\nDeployments successful!" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/node_builder.sh b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/node_builder.sh new file mode 100755 index 0000000000..940017e330 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/node_builder.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +git clone https://github.com/MystenLabs/sui.git --branch devnet +cd sui +# Corresponds to https://github.com/MystenLabs/sui/releases/tag/mainnet-v1.19.1 +git reset --hard 041c5f2bae2fe52079e44b70514333532d69f4e6 + +cargo --locked install --path crates/sui +cargo --locked install --path crates/sui-faucet +cargo --locked install --path crates/sui-gateway +cargo --locked install --path crates/sui-node diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/register_devnet.sh b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/register_devnet.sh new file mode 100755 index 0000000000..79df935672 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/register_devnet.sh @@ -0,0 +1,22 @@ +#!/bin/bash + +set -e + +DOTENV=$(realpath "$(dirname "$0")"/../.env) +[ -f $DOTENV ] || (echo "$DOTENV does not exist." >&2; exit 1) + +# 1. load variables from .env file +. $DOTENV + +# 2. next we get all the token bridge registration VAAs from the environment +# if a new VAA is added, this will automatically pick it up +VAAS=$(set | grep "REGISTER_.*_TOKEN_BRIDGE_VAA" | grep -v SUI | cut -d '=' -f1) + +# 3. use 'worm' to submit each registration VAA +for VAA in $VAAS +do + VAA=${!VAA} + worm submit $VAA --chain sui --network devnet +done + +echo "Registrations successful." diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/setup_rust.sh b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/setup_rust.sh new file mode 100755 index 0000000000..3738ba9548 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/setup_rust.sh @@ -0,0 +1,3 @@ +#!/bin/bash + +curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/start_node.sh b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/start_node.sh new file mode 100755 index 0000000000..2ffce35438 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/start_node.sh @@ -0,0 +1,5 @@ +#!/bin/bash + +set -x + +sui start 2>&1 diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/switch.sh b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/switch.sh new file mode 100755 index 0000000000..caba0f4b70 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/switch.sh @@ -0,0 +1,31 @@ +#!/bin/bash + +network="$1" +valid_networks=("devnet" "testnet" "mainnet" "reset") + +usage() { + echo "Usage: $0 {devnet|testnet|mainnet|reset}" >&2 + exit 1 +} + +if [[ ! " ${valid_networks[@]} " =~ " ${network} " ]]; then + echo "Error: Unrecognized network '${network}'." + usage +fi + +git ls-files | grep 'Move.toml' | while read -r file; do + if [[ "$network" == "reset" ]]; then + echo "Resetting $file" + git checkout "$file" --quiet + else + dir=$(dirname "$file") + base=$(basename "$file") + new_file="${dir}/Move.$network.toml" + if [ -f "$new_file" ]; then + echo "Switching $file to $new_file" + rm "$file" + # Create a relative symlink + (cd "$dir" && ln -s "$(basename "$new_file")" "$base") + fi + fi +done diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/wait_for_devnet.sh b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/wait_for_devnet.sh new file mode 100755 index 0000000000..ff0b00355e --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/scripts/wait_for_devnet.sh @@ -0,0 +1,6 @@ +#!/bin/bash + +set -e + +# Wait for sui to start +while [[ "$(curl -X POST -H "Content-Type: application/json" -d '{ "jsonrpc":"2.0", "method":"rpc.discover","id":1 }' -s -o /dev/null -w '%{http_code}' 0.0.0.0:9000/)" != "200" ]]; do sleep 1; done diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/.gitignore b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/.gitignore new file mode 100644 index 0000000000..b552b7394c --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/.gitignore @@ -0,0 +1,4 @@ +node_modules +sui.log.* +./token_bridge/ +./wormhole/ diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/Makefile b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/Makefile new file mode 100644 index 0000000000..60c5246198 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/Makefile @@ -0,0 +1,13 @@ +-include ../Makefile.help + +.PHONY: clean +clean: + rm -rf node_modules + +node_modules: + pnpm i + +.PHONY: test +## Run tests +test: node_modules + bash run_integration_test.sh diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/00_environment.ts b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/00_environment.ts new file mode 100644 index 0000000000..3ca09f236d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/00_environment.ts @@ -0,0 +1,78 @@ +import { expect } from "chai"; +import * as mock from "@certusone/wormhole-sdk/lib/cjs/mock"; + +import { + CREATOR_PRIVATE_KEY, + GUARDIAN_PRIVATE_KEY, + RELAYER_PRIVATE_KEY, + WALLET_PRIVATE_KEY, +} from "./helpers/consts"; +import { + Ed25519Keypair, + JsonRpcProvider, + localnetConnection, + RawSigner, +} from "@mysten/sui.js"; + +describe(" 0. Environment", () => { + const provider = new JsonRpcProvider(localnetConnection); + + // User wallet. + const wallet = new RawSigner( + Ed25519Keypair.fromSecretKey(WALLET_PRIVATE_KEY), + provider + ); + + // Relayer wallet. + const relayer = new RawSigner( + Ed25519Keypair.fromSecretKey(RELAYER_PRIVATE_KEY), + provider + ); + + // Deployer wallet. + const creator = new RawSigner( + Ed25519Keypair.fromSecretKey(CREATOR_PRIVATE_KEY), + provider + ); + + describe("Verify Local Validator", () => { + it("Balance", async () => { + // Balance check wallet. + { + const coinData = await wallet + .getAddress() + .then((owner) => + provider + .getCoins({ owner, coinType: "0x2::sui::SUI" }) + .then((result) => result.data) + ); + expect(coinData).has.length(5); + } + + // Balance check relayer. + { + const coinData = await relayer + .getAddress() + .then((owner) => + provider + .getCoins({ owner, coinType: "0x2::sui::SUI" }) + .then((result) => result.data) + ); + expect(coinData).has.length(5); + } + + // Balance check creator. This should only have one gas object at this + // point. + { + const coinData = await creator + .getAddress() + .then((owner) => + provider + .getCoins({ owner, coinType: "0x2::sui::SUI" }) + .then((result) => result.data) + ); + expect(coinData).has.length(1); + } + }); + }); +}); diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/01_wormhole.ts b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/01_wormhole.ts new file mode 100644 index 0000000000..ae9a26f08b --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/01_wormhole.ts @@ -0,0 +1,109 @@ +import { expect } from "chai"; + +import { WALLET_PRIVATE_KEY, WORMHOLE_STATE_ID } from "./helpers/consts"; +import { + Ed25519Keypair, + JsonRpcProvider, + localnetConnection, + RawSigner, + SUI_CLOCK_OBJECT_ID, + TransactionBlock, +} from "@mysten/sui.js"; +import { getPackageId } from "./helpers/utils"; +import { addPrepareMessageAndPublishMessage } from "./helpers/wormhole/testPublishMessage"; + +describe(" 1. Wormhole", () => { + const provider = new JsonRpcProvider(localnetConnection); + + // User wallet. + const wallet = new RawSigner( + Ed25519Keypair.fromSecretKey(WALLET_PRIVATE_KEY), + provider + ); + + describe("Publish Message", () => { + it("Check `WormholeMessage` Event", async () => { + const wormholePackage = await getPackageId( + wallet.provider, + WORMHOLE_STATE_ID + ); + + const owner = await wallet.getAddress(); + + // Create emitter cap. + const emitterCapId = await (async () => { + const tx = new TransactionBlock(); + const [emitterCap] = tx.moveCall({ + target: `${wormholePackage}::emitter::new`, + arguments: [tx.object(WORMHOLE_STATE_ID)], + }); + tx.transferObjects([emitterCap], tx.pure(owner)); + + // Execute and fetch created Emitter cap. + return wallet + .signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showObjectChanges: true, + }, + }) + .then((result) => { + const found = result.objectChanges?.filter( + (item) => "created" === item.type! + ); + if (found?.length == 1 && "objectId" in found[0]) { + return found[0].objectId; + } + + throw new Error("no objects found"); + }); + })(); + + // Publish messages using emitter cap. + { + const nonce = 69; + const basePayload = "All your base are belong to us."; + + const numMessages = 32; + const payloads: string[] = []; + const tx = new TransactionBlock(); + + // Construct transaction block to send multiple messages. + for (let i = 0; i < numMessages; ++i) { + // Make a unique message. + const payload = basePayload + `... ${i}`; + payloads.push(payload); + + addPrepareMessageAndPublishMessage( + tx, + wormholePackage, + WORMHOLE_STATE_ID, + emitterCapId, + nonce, + payload + ); + } + + const events = await wallet + .signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEvents: true, + }, + }) + .then((result) => result.events!); + expect(events).has.length(numMessages); + + for (let i = 0; i < numMessages; ++i) { + const eventData = events[i].parsedJson!; + expect(eventData.consistency_level).equals(0); + expect(eventData.nonce).equals(nonce); + expect(eventData.payload).deep.equals([...Buffer.from(payloads[i])]); + expect(eventData.sender).equals(emitterCapId); + expect(eventData.sequence).equals(i.toString()); + expect(BigInt(eventData.timestamp) > 0n).is.true; + } + } + }); + }); +}); diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/build.ts b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/build.ts new file mode 100644 index 0000000000..374831ab8f --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/build.ts @@ -0,0 +1,32 @@ +import { fromB64, normalizeSuiObjectId } from "@mysten/sui.js"; +import { execSync, ExecSyncOptionsWithStringEncoding } from "child_process"; +import { UTF8 } from "./consts"; + +export const EXEC_UTF8: ExecSyncOptionsWithStringEncoding = { encoding: UTF8 }; + +export function buildForBytecode(packagePath: string) { + const buildOutput: { + modules: string[]; + dependencies: string[]; + } = JSON.parse( + execSync( + `sui move build --dump-bytecode-as-base64 -p ${packagePath} 2> /dev/null`, + EXEC_UTF8 + ) + ); + return { + modules: buildOutput.modules.map((m: string) => Array.from(fromB64(m))), + dependencies: buildOutput.dependencies.map((d: string) => + normalizeSuiObjectId(d) + ), + }; +} + +export function buildForDigest(packagePath: string) { + const digest = execSync( + `sui move build --dump-package-digest -p ${packagePath} 2> /dev/null`, + EXEC_UTF8 + ).substring(0, 64); + + return Buffer.from(digest, "hex"); +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/consts.ts b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/consts.ts new file mode 100644 index 0000000000..c4aa0787f4 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/consts.ts @@ -0,0 +1,40 @@ +// NOTE: modify these to reflect current versions of packages +export const VERSION_WORMHOLE = 1; +export const VERSION_TOKEN_BRIDGE = 1; + +// keystore +export const KEYSTORE = [ + "AB522qKKEsXMTFRD2SG3Het/02S/ZBOugmcH3R1CDG6l", + "AOmPq9B16F3W3ijO/4s9hI6v8LdiYCawKAW31PKpg4Qp", + "AGA20wtGcwbcNAG4nwapbQ5wIuXwkYQEWFUoSVAxctHb", +]; + +// wallets +export const WALLET_PRIVATE_KEY = Buffer.from(KEYSTORE[0], "base64").subarray( + 1 +); +export const RELAYER_PRIVATE_KEY = Buffer.from(KEYSTORE[1], "base64").subarray( + 1 +); +export const CREATOR_PRIVATE_KEY = Buffer.from(KEYSTORE[2], "base64").subarray( + 1 +); + +// guardian signer +export const GUARDIAN_PRIVATE_KEY = + "cfb12303a19cde580bb4dd771639b0d26bc68353645571a8cff516ab2ee113a0"; + +// wormhole +export const WORMHOLE_STATE_ID = + "0xc561a02a143575e53b87ba6c1476f053a307eac5179cb1c8121a3d3b220b81c1"; + +// token bridge +export const TOKEN_BRIDGE_STATE_ID = + "0x1c8de839f6331f2d745eb53b1b595bc466b4001c11617b0b66214b2e25ee72fc"; + +// governance +export const GOVERNANCE_EMITTER = + "0000000000000000000000000000000000000000000000000000000000000004"; + +// file encoding +export const UTF8: BufferEncoding = "utf-8"; diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/error/moveAbort.ts b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/error/moveAbort.ts new file mode 100644 index 0000000000..04fdde7524 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/error/moveAbort.ts @@ -0,0 +1,42 @@ +export function parseMoveAbort(errorMessage: string) { + const parsed = errorMessage.matchAll( + /MoveAbort\(MoveLocation { module: ModuleId { address: ([0-9a-f]{64}), name: Identifier\("([A-Za-z_]+)"\) }, function: ([0-9]+), instruction: ([0-9]+), function_name: Some\("([A-Za-z_]+)"\) }, ([0-9]+)\) in command ([0-9]+)/g + ); + + return parsed.next().value.slice(1, 8); +} + +export class MoveAbort { + packageId: string; + moduleName: string; + functionName: string; + errorCode: bigint; + command: number; + + constructor( + packageId: string, + moduleName: string, + functionName: string, + errorCode: string, + command: string + ) { + this.packageId = packageId; + this.moduleName = moduleName; + this.functionName = functionName; + this.errorCode = BigInt(errorCode); + this.command = Number(command); + } + + static parseError(errorMessage: string): MoveAbort { + const [packageId, moduleName, , , functionName, errorCode, command] = + parseMoveAbort(errorMessage); + + return new MoveAbort( + "0x" + packageId, + moduleName, + functionName, + errorCode, + command + ); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/error/wormhole.ts b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/error/wormhole.ts new file mode 100644 index 0000000000..f011d606df --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/error/wormhole.ts @@ -0,0 +1,22 @@ +import { MoveAbort } from "./moveAbort"; + +export function parseWormholeError(errorMessage: string) { + const abort = MoveAbort.parseError(errorMessage); + const code = abort.errorCode; + + switch (abort.moduleName) { + case "required_version": { + switch (code) { + case 0n: { + return "E_OUTDATED_VERSION"; + } + default: { + throw new Error(`unrecognized error code: ${abort}`); + } + } + } + default: { + throw new Error(`unrecognized module: ${abort}`); + } + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/setup.ts b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/setup.ts new file mode 100644 index 0000000000..0399be84e7 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/setup.ts @@ -0,0 +1,75 @@ +import * as fs from "fs"; +import * as mock from "@certusone/wormhole-sdk/lib/cjs/mock"; +import { GUARDIAN_PRIVATE_KEY, UTF8 } from "./consts"; + +export function generateVaaFromDigest( + digest: Buffer, + governance: mock.GovernanceEmitter +) { + const timestamp = 12345678; + const published = governance.publishWormholeUpgradeContract( + timestamp, + 2, + "0x" + digest.toString("hex") + ); + + // Sui is not supported yet by the SDK, so we need to adjust the payload. + published.writeUInt16BE(21, published.length - 34); + + // We will use the signed VAA when we execute the upgrade. + const guardians = new mock.MockGuardians(0, [GUARDIAN_PRIVATE_KEY]); + return guardians.addSignatures(published, [0]); +} + +export function modifyHardCodedVersionControl( + packagePath: string, + currentVersion: number, + newVersion: number +) { + const versionControlDotMove = `${packagePath}/sources/version_control.move`; + + const contents = fs.readFileSync(versionControlDotMove, UTF8); + const src = `const CURRENT_BUILD_VERSION: u64 = ${currentVersion}`; + if (contents.indexOf(src) < 0) { + throw new Error("current version not found"); + } + + const dst = `const CURRENT_BUILD_VERSION: u64 = ${newVersion}`; + fs.writeFileSync(versionControlDotMove, contents.replace(src, dst), UTF8); +} + +export function setUpWormholeDirectory( + srcWormholePath: string, + dstWormholePath: string +) { + fs.cpSync(srcWormholePath, dstWormholePath, { recursive: true }); + + // Remove irrelevant files. This part is not necessary, but is helpful + // for debugging a clean package directory. + const removeThese = [ + "Move.devnet.toml", + "Move.lock", + "Makefile", + "README.md", + "build", + ]; + for (const basename of removeThese) { + fs.rmSync(`${dstWormholePath}/${basename}`, { + recursive: true, + force: true, + }); + } + + // Fix Move.toml file. + const moveTomlPath = `${dstWormholePath}/Move.toml`; + const moveToml = fs.readFileSync(moveTomlPath, UTF8); + fs.writeFileSync( + moveTomlPath, + moveToml.replace(`wormhole = "_"`, `wormhole = "0x0"`), + UTF8 + ); +} + +export function cleanUpPackageDirectory(packagePath: string) { + fs.rmSync(packagePath, { recursive: true, force: true }); +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/upgrade.ts b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/upgrade.ts new file mode 100644 index 0000000000..4698e9a85b --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/upgrade.ts @@ -0,0 +1,73 @@ +import { + RawSigner, + SUI_CLOCK_OBJECT_ID, + TransactionBlock, +} from "@mysten/sui.js"; +import { buildForBytecode } from "./build"; +import { getPackageId } from "./utils"; + +export async function buildAndUpgradeWormhole( + signer: RawSigner, + signedVaa: Buffer, + wormholePath: string, + wormholeStateId: string +) { + const wormholePackage = await getPackageId(signer.provider, wormholeStateId); + + const tx = new TransactionBlock(); + + // Authorize upgrade. + const [upgradeTicket] = tx.moveCall({ + target: `${wormholePackage}::upgrade_contract::authorize_upgrade`, + arguments: [ + tx.object(wormholeStateId), + tx.pure(Array.from(signedVaa)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + // Build and generate modules and dependencies for upgrade. + const { modules, dependencies } = buildForBytecode(wormholePath); + const [upgradeReceipt] = tx.upgrade({ + modules, + dependencies, + packageId: wormholePackage, + ticket: upgradeTicket, + }); + + // Commit upgrade. + tx.moveCall({ + target: `${wormholePackage}::upgrade_contract::commit_upgrade`, + arguments: [tx.object(wormholeStateId), upgradeReceipt], + }); + + // Cannot auto compute gas budget, so we need to configure it manually. + // Gas ~215m. + tx.setGasBudget(215_000_000n); + + return signer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} + +export async function migrate(signer: RawSigner, stateId: string) { + const contractPackage = await getPackageId(signer.provider, stateId); + + const tx = new TransactionBlock(); + tx.moveCall({ + target: `${contractPackage}::migrate::migrate`, + arguments: [tx.object(stateId)], + }); + + return signer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/utils.ts b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/utils.ts new file mode 100644 index 0000000000..58f71444e1 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/utils.ts @@ -0,0 +1,27 @@ +import { JsonRpcProvider } from "@mysten/sui.js"; + +export async function getPackageId( + provider: JsonRpcProvider, + stateId: string +): Promise { + const state = await provider + .getObject({ + id: stateId, + options: { + showContent: true, + }, + }) + .then((result) => { + if (result.data?.content?.dataType == "moveObject") { + return result.data.content.fields; + } + + throw new Error("not move object"); + }); + + if ("upgrade_cap" in state) { + return state.upgrade_cap.fields.package; + } + + throw new Error("upgrade_cap not found"); +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/wormhole/testPublishMessage.ts b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/wormhole/testPublishMessage.ts new file mode 100644 index 0000000000..35a3876a51 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/js/helpers/wormhole/testPublishMessage.ts @@ -0,0 +1,31 @@ +import { SUI_CLOCK_OBJECT_ID, TransactionBlock } from "@mysten/sui.js"; + +export function addPrepareMessageAndPublishMessage( + tx: TransactionBlock, + wormholePackage: string, + wormholeStateId: string, + emitterCapId: string, + nonce: number, + payload: number[] | string +): TransactionBlock { + const [feeAmount] = tx.moveCall({ + target: `${wormholePackage}::state::message_fee`, + arguments: [tx.object(wormholeStateId)], + }); + const [wormholeFee] = tx.splitCoins(tx.gas, [feeAmount]); + const [messageTicket] = tx.moveCall({ + target: `${wormholePackage}::publish_message::prepare_message`, + arguments: [tx.object(emitterCapId), tx.pure(nonce), tx.pure(payload)], + }); + tx.moveCall({ + target: `${wormholePackage}::publish_message::publish_message`, + arguments: [ + tx.object(wormholeStateId), + wormholeFee, + messageTicket, + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + return tx; +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/package-lock.json b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/package-lock.json new file mode 100644 index 0000000000..3b6dd637e6 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/package-lock.json @@ -0,0 +1,5917 @@ +{ + "name": "wormhole-sui-integration-test", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "wormhole-sui-integration-test", + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "@certusone/wormhole-sdk": "^0.9.12", + "@mysten/sui.js": "^0.32.2", + "chai": "^4.3.7", + "mocha": "^10.2.0", + "prettier": "^2.8.7", + "ts-mocha": "^10.0.0", + "ts-node": "^10.9.1", + "typescript": "^5.0.4" + }, + "devDependencies": { + "@types/chai": "^4.3.4", + "@types/mocha": "^10.0.1", + "@types/node": "^18.15.11" + } + }, + "node_modules/@apollo/client": { + "version": "3.7.11", + "resolved": "https://registry.npmjs.org/@apollo/client/-/client-3.7.11.tgz", + "integrity": "sha512-uLg2KtxoAyj9ta7abLxXx8cGRM7HypCkXVmxtL7Ko//N5g37aoJ3ca7VYoFCMUFO1BXBulj+yKVl0U3+ILj5AQ==", + "license": "MIT", + "dependencies": { + "@graphql-typed-document-node/core": "^3.1.1", + "@wry/context": "^0.7.0", + "@wry/equality": "^0.5.0", + "@wry/trie": "^0.3.0", + "graphql-tag": "^2.12.6", + "hoist-non-react-statics": "^3.3.2", + "optimism": "^0.16.2", + "prop-types": "^15.7.2", + "response-iterator": "^0.2.6", + "symbol-observable": "^4.0.0", + "ts-invariant": "^0.10.3", + "tslib": "^2.3.0", + "zen-observable-ts": "^1.2.5" + }, + "peerDependencies": { + "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0", + "graphql-ws": "^5.5.5", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0", + "subscriptions-transport-ws": "^0.9.0 || ^0.11.0" + }, + "peerDependenciesMeta": { + "graphql-ws": { + "optional": true + }, + "react": { + "optional": true + }, + "react-dom": { + "optional": true + }, + "subscriptions-transport-ws": { + "optional": true + } + } + }, + "node_modules/@babel/runtime": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.21.0.tgz", + "integrity": "sha512-xwII0//EObnq89Ji5AKYQaRYiW/nZ3llSv29d49IuxPhKbtJoLP+9QUUZ4nVragQVtaVGeZrpB+ZtG/Pdy/POw==", + "license": "MIT", + "dependencies": { + "regenerator-runtime": "^0.13.11" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@certusone/wormhole-sdk": { + "version": "0.9.12", + "resolved": "https://registry.npmjs.org/@certusone/wormhole-sdk/-/wormhole-sdk-0.9.12.tgz", + "integrity": "sha512-ywMNc/tHg6qb9dcZLND1BMUISp7eFN+ksymOgjhwQcZZ/KUA/N1uVvbMVs0uSx+i0y4VloO9MwGc/uFnYKNsMQ==", + "license": "Apache-2.0", + "dependencies": { + "@certusone/wormhole-sdk-proto-web": "0.0.6", + "@certusone/wormhole-sdk-wasm": "^0.0.1", + "@coral-xyz/borsh": "0.2.6", + "@injectivelabs/networks": "^1.0.73", + "@injectivelabs/sdk-ts": "^1.0.368", + "@injectivelabs/utils": "^1.0.63", + "@project-serum/anchor": "^0.25.0", + "@solana/spl-token": "^0.3.5", + "@solana/web3.js": "^1.66.2", + "@terra-money/terra.js": "^3.1.3", + "@xpla/xpla.js": "^0.2.1", + "algosdk": "^1.15.0", + "aptos": "1.5.0", + "axios": "^0.24.0", + "bech32": "^2.0.0", + "binary-parser": "^2.2.1", + "bs58": "^4.0.1", + "elliptic": "^6.5.4", + "js-base64": "^3.6.1", + "near-api-js": "^1.0.0" + } + }, + "node_modules/@certusone/wormhole-sdk-proto-web": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/@certusone/wormhole-sdk-proto-web/-/wormhole-sdk-proto-web-0.0.6.tgz", + "integrity": "sha512-LTyjsrWryefx5WmkoBP6FQ2EjLxhMExAGxLkloHUhufVQZdrbGh0htBBUviP+HaDSJBCMPMtulNFwkBJV6muqQ==", + "license": "Apache-2.0", + "dependencies": { + "@improbable-eng/grpc-web": "^0.15.0", + "protobufjs": "^7.0.0", + "rxjs": "^7.5.6" + } + }, + "node_modules/@certusone/wormhole-sdk-proto-web/node_modules/@improbable-eng/grpc-web": { + "version": "0.15.0", + "resolved": "https://registry.npmjs.org/@improbable-eng/grpc-web/-/grpc-web-0.15.0.tgz", + "integrity": "sha512-ERft9/0/8CmYalqOVnJnpdDry28q+j+nAlFFARdjyxXDJ+Mhgv9+F600QC8BR9ygOfrXRlAk6CvST2j+JCpQPg==", + "license": "Apache-2.0", + "dependencies": { + "browser-headers": "^0.4.1" + }, + "peerDependencies": { + "google-protobuf": "^3.14.0" + } + }, + "node_modules/@certusone/wormhole-sdk-proto-web/node_modules/long": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/long/-/long-5.2.1.tgz", + "integrity": "sha512-GKSNGeNAtw8IryjjkhZxuKB3JzlcLTwjtiQCHKvqQet81I93kXslhDQruGI/QsddO83mcDToBVy7GqGS/zYf/A==", + "license": "Apache-2.0" + }, + "node_modules/@certusone/wormhole-sdk-proto-web/node_modules/protobufjs": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.2.3.tgz", + "integrity": "sha512-TtpvOqwB5Gdz/PQmOjgsrGH1nHjAQVCN7JG4A6r1sXRWESL5rNMAiRcBQlCAdKxZcAbstExQePYG8xof/JVRgg==", + "hasInstallScript": true, + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/node": ">=13.7.0", + "long": "^5.0.0" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@certusone/wormhole-sdk-wasm": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/@certusone/wormhole-sdk-wasm/-/wormhole-sdk-wasm-0.0.1.tgz", + "integrity": "sha512-LdIwLhOyr4pPs2jqYubqC7d4UkqYBX0EG/ppspQlW3qlVE0LZRMrH6oVzzLMyHtV0Rw7O9sIKzORW/T3mrJv2w==", + "license": "Apache-2.0", + "dependencies": { + "@types/long": "^4.0.2", + "@types/node": "^18.0.3" + } + }, + "node_modules/@certusone/wormhole-sdk/node_modules/axios": { + "version": "0.24.0", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.24.0.tgz", + "integrity": "sha512-Q6cWsys88HoPgAaFAVUb0WpPk0O8iTeisR9IMqy9G8AbO4NlpVknrnQS03zzF9PGAWgO3cgletO3VjV/P7VztA==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.14.4" + } + }, + "node_modules/@classic-terra/terra.proto": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@classic-terra/terra.proto/-/terra.proto-1.1.0.tgz", + "integrity": "sha512-bYhQG5LUaGF0KPRY9hYT/HEcd1QExZPQd6zLV/rQkCe/eDxfwFRLzZHpaaAdfWoAAZjsRWqJbUCqCg7gXBbJpw==", + "license": "Apache-2.0", + "dependencies": { + "@improbable-eng/grpc-web": "^0.14.1", + "google-protobuf": "^3.17.3", + "long": "^4.0.0", + "protobufjs": "~6.11.2" + } + }, + "node_modules/@confio/ics23": { + "version": "0.6.8", + "resolved": "https://registry.npmjs.org/@confio/ics23/-/ics23-0.6.8.tgz", + "integrity": "sha512-wB6uo+3A50m0sW/EWcU64xpV/8wShZ6bMTa7pF8eYsTrSkQA7oLUIJcs/wb8g4y2Oyq701BaGiO6n/ak5WXO1w==", + "license": "Apache-2.0", + "dependencies": { + "@noble/hashes": "^1.0.0", + "protobufjs": "^6.8.8" + } + }, + "node_modules/@coral-xyz/borsh": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/@coral-xyz/borsh/-/borsh-0.2.6.tgz", + "integrity": "sha512-y6nmHw1bFcJib7sMHsQPpC8r47xhqDZVvhUdna7NUPzpSbOZG6f46N21+aXsQ2w/tG8Ggls488J/ZmwbgVmyjg==", + "license": "Apache-2.0", + "dependencies": { + "bn.js": "^5.1.2", + "buffer-layout": "^1.2.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@solana/web3.js": "^1.2.0" + } + }, + "node_modules/@cosmjs/amino": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/amino/-/amino-0.30.1.tgz", + "integrity": "sha512-yNHnzmvAlkETDYIpeCTdVqgvrdt1qgkOXwuRVi8s27UKI5hfqyE9fJ/fuunXE6ZZPnKkjIecDznmuUOMrMvw4w==", + "license": "Apache-2.0", + "dependencies": { + "@cosmjs/crypto": "^0.30.1", + "@cosmjs/encoding": "^0.30.1", + "@cosmjs/math": "^0.30.1", + "@cosmjs/utils": "^0.30.1" + } + }, + "node_modules/@cosmjs/crypto": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/crypto/-/crypto-0.30.1.tgz", + "integrity": "sha512-rAljUlake3MSXs9xAm87mu34GfBLN0h/1uPPV6jEwClWjNkAMotzjC0ab9MARy5FFAvYHL3lWb57bhkbt2GtzQ==", + "license": "Apache-2.0", + "dependencies": { + "@cosmjs/encoding": "^0.30.1", + "@cosmjs/math": "^0.30.1", + "@cosmjs/utils": "^0.30.1", + "@noble/hashes": "^1", + "bn.js": "^5.2.0", + "elliptic": "^6.5.4", + "libsodium-wrappers": "^0.7.6" + } + }, + "node_modules/@cosmjs/encoding": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/encoding/-/encoding-0.30.1.tgz", + "integrity": "sha512-rXmrTbgqwihORwJ3xYhIgQFfMSrwLu1s43RIK9I8EBudPx3KmnmyAKzMOVsRDo9edLFNuZ9GIvysUCwQfq3WlQ==", + "license": "Apache-2.0", + "dependencies": { + "base64-js": "^1.3.0", + "bech32": "^1.1.4", + "readonly-date": "^1.0.0" + } + }, + "node_modules/@cosmjs/encoding/node_modules/bech32": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/bech32/-/bech32-1.1.4.tgz", + "integrity": "sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ==", + "license": "MIT" + }, + "node_modules/@cosmjs/json-rpc": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/json-rpc/-/json-rpc-0.30.1.tgz", + "integrity": "sha512-pitfC/2YN9t+kXZCbNuyrZ6M8abnCC2n62m+JtU9vQUfaEtVsgy+1Fk4TRQ175+pIWSdBMFi2wT8FWVEE4RhxQ==", + "license": "Apache-2.0", + "dependencies": { + "@cosmjs/stream": "^0.30.1", + "xstream": "^11.14.0" + } + }, + "node_modules/@cosmjs/math": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/math/-/math-0.30.1.tgz", + "integrity": "sha512-yaoeI23pin9ZiPHIisa6qqLngfnBR/25tSaWpkTm8Cy10MX70UF5oN4+/t1heLaM6SSmRrhk3psRkV4+7mH51Q==", + "license": "Apache-2.0", + "dependencies": { + "bn.js": "^5.2.0" + } + }, + "node_modules/@cosmjs/proto-signing": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/proto-signing/-/proto-signing-0.30.1.tgz", + "integrity": "sha512-tXh8pPYXV4aiJVhTKHGyeZekjj+K9s2KKojMB93Gcob2DxUjfKapFYBMJSgfKPuWUPEmyr8Q9km2hplI38ILgQ==", + "license": "Apache-2.0", + "dependencies": { + "@cosmjs/amino": "^0.30.1", + "@cosmjs/crypto": "^0.30.1", + "@cosmjs/encoding": "^0.30.1", + "@cosmjs/math": "^0.30.1", + "@cosmjs/utils": "^0.30.1", + "cosmjs-types": "^0.7.1", + "long": "^4.0.0" + } + }, + "node_modules/@cosmjs/socket": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/socket/-/socket-0.30.1.tgz", + "integrity": "sha512-r6MpDL+9N+qOS/D5VaxnPaMJ3flwQ36G+vPvYJsXArj93BjgyFB7BwWwXCQDzZ+23cfChPUfhbINOenr8N2Kow==", + "license": "Apache-2.0", + "dependencies": { + "@cosmjs/stream": "^0.30.1", + "isomorphic-ws": "^4.0.1", + "ws": "^7", + "xstream": "^11.14.0" + } + }, + "node_modules/@cosmjs/stargate": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/stargate/-/stargate-0.30.1.tgz", + "integrity": "sha512-RdbYKZCGOH8gWebO7r6WvNnQMxHrNXInY/gPHPzMjbQF6UatA6fNM2G2tdgS5j5u7FTqlCI10stNXrknaNdzog==", + "license": "Apache-2.0", + "dependencies": { + "@confio/ics23": "^0.6.8", + "@cosmjs/amino": "^0.30.1", + "@cosmjs/encoding": "^0.30.1", + "@cosmjs/math": "^0.30.1", + "@cosmjs/proto-signing": "^0.30.1", + "@cosmjs/stream": "^0.30.1", + "@cosmjs/tendermint-rpc": "^0.30.1", + "@cosmjs/utils": "^0.30.1", + "cosmjs-types": "^0.7.1", + "long": "^4.0.0", + "protobufjs": "~6.11.3", + "xstream": "^11.14.0" + } + }, + "node_modules/@cosmjs/stream": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/stream/-/stream-0.30.1.tgz", + "integrity": "sha512-Fg0pWz1zXQdoxQZpdHRMGvUH5RqS6tPv+j9Eh7Q953UjMlrwZVo0YFLC8OTf/HKVf10E4i0u6aM8D69Q6cNkgQ==", + "license": "Apache-2.0", + "dependencies": { + "xstream": "^11.14.0" + } + }, + "node_modules/@cosmjs/tendermint-rpc": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/tendermint-rpc/-/tendermint-rpc-0.30.1.tgz", + "integrity": "sha512-Z3nCwhXSbPZJ++v85zHObeUggrEHVfm1u18ZRwXxFE9ZMl5mXTybnwYhczuYOl7KRskgwlB+rID0WYACxj4wdQ==", + "license": "Apache-2.0", + "dependencies": { + "@cosmjs/crypto": "^0.30.1", + "@cosmjs/encoding": "^0.30.1", + "@cosmjs/json-rpc": "^0.30.1", + "@cosmjs/math": "^0.30.1", + "@cosmjs/socket": "^0.30.1", + "@cosmjs/stream": "^0.30.1", + "@cosmjs/utils": "^0.30.1", + "axios": "^0.21.2", + "readonly-date": "^1.0.0", + "xstream": "^11.14.0" + } + }, + "node_modules/@cosmjs/utils": { + "version": "0.30.1", + "resolved": "https://registry.npmjs.org/@cosmjs/utils/-/utils-0.30.1.tgz", + "integrity": "sha512-KvvX58MGMWh7xA+N+deCfunkA/ZNDvFLw4YbOmX3f/XBIkqrVY7qlotfy2aNb1kgp6h4B6Yc8YawJPDTfvWX7g==", + "license": "Apache-2.0" + }, + "node_modules/@cspotcode/source-map-support": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz", + "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==", + "dependencies": { + "@jridgewell/trace-mapping": "0.3.9" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@ethereumjs/common": { + "version": "2.6.5", + "resolved": "https://registry.npmjs.org/@ethereumjs/common/-/common-2.6.5.tgz", + "integrity": "sha512-lRyVQOeCDaIVtgfbowla32pzeDv2Obr8oR8Put5RdUBNRGr1VGPGQNGP6elWIpgK3YdpzqTOh4GyUGOureVeeA==", + "license": "MIT", + "dependencies": { + "crc-32": "^1.2.0", + "ethereumjs-util": "^7.1.5" + } + }, + "node_modules/@ethereumjs/tx": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/@ethereumjs/tx/-/tx-3.5.2.tgz", + "integrity": "sha512-gQDNJWKrSDGu2w7w0PzVXVBNMzb7wwdDOmOqczmhNjqFxFuIbhVJDwiGEnxFNC2/b8ifcZzY7MLcluizohRzNw==", + "license": "MPL-2.0", + "dependencies": { + "@ethereumjs/common": "^2.6.4", + "ethereumjs-util": "^7.1.5" + } + }, + "node_modules/@ethersproject/abi": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.7.0.tgz", + "integrity": "sha512-351ktp42TiRcYB3H1OP8yajPeAQstMW/yCFokj/AthP9bLHzQFPlOrxOcwYEDkUAICmOHljvN4K39OMTMUa9RA==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@ethersproject/abstract-provider": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abstract-provider/-/abstract-provider-5.7.0.tgz", + "integrity": "sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/networks": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/web": "^5.7.0" + } + }, + "node_modules/@ethersproject/abstract-signer": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abstract-signer/-/abstract-signer-5.7.0.tgz", + "integrity": "sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0" + } + }, + "node_modules/@ethersproject/address": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/address/-/address-5.7.0.tgz", + "integrity": "sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/rlp": "^5.7.0" + } + }, + "node_modules/@ethersproject/base64": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/base64/-/base64-5.7.0.tgz", + "integrity": "sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0" + } + }, + "node_modules/@ethersproject/basex": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/basex/-/basex-5.7.0.tgz", + "integrity": "sha512-ywlh43GwZLv2Voc2gQVTKBoVQ1mti3d8HK5aMxsfu/nRDnMmNqaSJ3r3n85HBByT8OpoY96SXM1FogC533T4zw==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/properties": "^5.7.0" + } + }, + "node_modules/@ethersproject/bignumber": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/bignumber/-/bignumber-5.7.0.tgz", + "integrity": "sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "bn.js": "^5.2.1" + } + }, + "node_modules/@ethersproject/bytes": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/bytes/-/bytes-5.7.0.tgz", + "integrity": "sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/constants": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.7.0.tgz", + "integrity": "sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bignumber": "^5.7.0" + } + }, + "node_modules/@ethersproject/contracts": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/contracts/-/contracts-5.7.0.tgz", + "integrity": "sha512-5GJbzEU3X+d33CdfPhcyS+z8MzsTrBGk/sc+G+59+tPa9yFkl6HQ9D6L0QMgNTA9q8dT0XKxxkyp883XsQvbbg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abi": "^5.7.0", + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/transactions": "^5.7.0" + } + }, + "node_modules/@ethersproject/hash": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.7.0.tgz", + "integrity": "sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/base64": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@ethersproject/hdnode": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/hdnode/-/hdnode-5.7.0.tgz", + "integrity": "sha512-OmyYo9EENBPPf4ERhR7oj6uAtUAhYGqOnIS+jE5pTXvdKBS99ikzq1E7Iv0ZQZ5V36Lqx1qZLeak0Ra16qpeOg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/basex": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/pbkdf2": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/sha2": "^5.7.0", + "@ethersproject/signing-key": "^5.7.0", + "@ethersproject/strings": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/wordlists": "^5.7.0" + } + }, + "node_modules/@ethersproject/json-wallets": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/json-wallets/-/json-wallets-5.7.0.tgz", + "integrity": "sha512-8oee5Xgu6+RKgJTkvEMl2wDgSPSAQ9MB/3JYjFV9jlKvcYHUXZC+cQp0njgmxdHkYWn8s6/IqIZYm0YWCjO/0g==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/hdnode": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/pbkdf2": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/random": "^5.7.0", + "@ethersproject/strings": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "aes-js": "3.0.0", + "scrypt-js": "3.0.1" + } + }, + "node_modules/@ethersproject/keccak256": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/keccak256/-/keccak256-5.7.0.tgz", + "integrity": "sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "js-sha3": "0.8.0" + } + }, + "node_modules/@ethersproject/logger": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.7.0.tgz", + "integrity": "sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT" + }, + "node_modules/@ethersproject/networks": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.7.1.tgz", + "integrity": "sha512-n/MufjFYv3yFcUyfhnXotyDlNdFb7onmkSy8aQERi2PjNcnWQ66xXxa3XlS8nCcA8aJKJjIIMNJTC7tu80GwpQ==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/pbkdf2": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/pbkdf2/-/pbkdf2-5.7.0.tgz", + "integrity": "sha512-oR/dBRZR6GTyaofd86DehG72hY6NpAjhabkhxgr3X2FpJtJuodEl2auADWBZfhDHgVCbu3/H/Ocq2uC6dpNjjw==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/sha2": "^5.7.0" + } + }, + "node_modules/@ethersproject/properties": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/properties/-/properties-5.7.0.tgz", + "integrity": "sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/providers": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.7.2.tgz", + "integrity": "sha512-g34EWZ1WWAVgr4aptGlVBF8mhl3VWjv+8hoAnzStu8Ah22VHBsuGzP17eb6xDVRzw895G4W7vvx60lFFur/1Rg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/base64": "^5.7.0", + "@ethersproject/basex": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/networks": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/random": "^5.7.0", + "@ethersproject/rlp": "^5.7.0", + "@ethersproject/sha2": "^5.7.0", + "@ethersproject/strings": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/web": "^5.7.0", + "bech32": "1.1.4", + "ws": "7.4.6" + } + }, + "node_modules/@ethersproject/providers/node_modules/bech32": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/bech32/-/bech32-1.1.4.tgz", + "integrity": "sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ==", + "license": "MIT" + }, + "node_modules/@ethersproject/providers/node_modules/ws": { + "version": "7.4.6", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.6.tgz", + "integrity": "sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A==", + "license": "MIT", + "engines": { + "node": ">=8.3.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/@ethersproject/random": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/random/-/random-5.7.0.tgz", + "integrity": "sha512-19WjScqRA8IIeWclFme75VMXSBvi4e6InrUNuaR4s5pTF2qNhcGdCUwdxUVGtDDqC00sDLCO93jPQoDUH4HVmQ==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/rlp": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/rlp/-/rlp-5.7.0.tgz", + "integrity": "sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/sha2": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/sha2/-/sha2-5.7.0.tgz", + "integrity": "sha512-gKlH42riwb3KYp0reLsFTokByAKoJdgFCwI+CCiX/k+Jm2mbNs6oOaCjYQSlI1+XBVejwH2KrmCbMAT/GnRDQw==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "hash.js": "1.1.7" + } + }, + "node_modules/@ethersproject/signing-key": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/signing-key/-/signing-key-5.7.0.tgz", + "integrity": "sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "bn.js": "^5.2.1", + "elliptic": "6.5.4", + "hash.js": "1.1.7" + } + }, + "node_modules/@ethersproject/solidity": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/solidity/-/solidity-5.7.0.tgz", + "integrity": "sha512-HmabMd2Dt/raavyaGukF4XxizWKhKQ24DoLtdNbBmNKUOPqwjsKQSdV9GQtj9CBEea9DlzETlVER1gYeXXBGaA==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/sha2": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@ethersproject/strings": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.7.0.tgz", + "integrity": "sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/transactions": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/transactions/-/transactions-5.7.0.tgz", + "integrity": "sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/rlp": "^5.7.0", + "@ethersproject/signing-key": "^5.7.0" + } + }, + "node_modules/@ethersproject/units": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/units/-/units-5.7.0.tgz", + "integrity": "sha512-pD3xLMy3SJu9kG5xDGI7+xhTEmGXlEqXU4OfNapmfnxLVY4EMSSRp7j1k7eezutBPH7RBN/7QPnwR7hzNlEFeg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/wallet": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/wallet/-/wallet-5.7.0.tgz", + "integrity": "sha512-MhmXlJXEJFBFVKrDLB4ZdDzxcBxQ3rLyCkhNqVu3CDYvR97E+8r01UgrI+TI99Le+aYm/in/0vp86guJuM7FCA==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/hdnode": "^5.7.0", + "@ethersproject/json-wallets": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/random": "^5.7.0", + "@ethersproject/signing-key": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/wordlists": "^5.7.0" + } + }, + "node_modules/@ethersproject/web": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/@ethersproject/web/-/web-5.7.1.tgz", + "integrity": "sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/base64": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@ethersproject/wordlists": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/wordlists/-/wordlists-5.7.0.tgz", + "integrity": "sha512-S2TFNJNfHWVHNE6cNDjbVlZ6MgE17MIxMbMg2zv3wn+3XSJGosL1m9ZVv3GXCf/2ymSsQ+hRI5IzoMJTG6aoVA==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@graphql-typed-document-node/core": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/@graphql-typed-document-node/core/-/core-3.2.0.tgz", + "integrity": "sha512-mB9oAsNCm9aM3/SOv4YtBMqZbYj10R7dkq8byBqxGY/ncFwhf2oQzMV+LCRlWoDSEBJ3COiR1yeDvMtsoOsuFQ==", + "license": "MIT", + "peerDependencies": { + "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0" + } + }, + "node_modules/@improbable-eng/grpc-web": { + "version": "0.14.1", + "resolved": "https://registry.npmjs.org/@improbable-eng/grpc-web/-/grpc-web-0.14.1.tgz", + "integrity": "sha512-XaIYuunepPxoiGVLLHmlnVminUGzBTnXr8Wv7khzmLWbNw4TCwJKX09GSMJlKhu/TRk6gms0ySFxewaETSBqgw==", + "license": "Apache-2.0", + "dependencies": { + "browser-headers": "^0.4.1" + }, + "peerDependencies": { + "google-protobuf": "^3.14.0" + } + }, + "node_modules/@injectivelabs/core-proto-ts": { + "version": "0.0.11", + "resolved": "https://registry.npmjs.org/@injectivelabs/core-proto-ts/-/core-proto-ts-0.0.11.tgz", + "integrity": "sha512-gYMzkoZ0olXLbEhSQVarUCMR6VAHytvENDv2Psjl9EjO5Pg93vTGLViS4E4vA5fezRfdF/x0Uic31w+ogp66jA==", + "license": "MIT", + "dependencies": { + "@injectivelabs/grpc-web": "^0.0.1", + "google-protobuf": "^3.14.0", + "protobufjs": "^7.0.0", + "rxjs": "^7.4.0" + } + }, + "node_modules/@injectivelabs/core-proto-ts/node_modules/long": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/long/-/long-5.2.1.tgz", + "integrity": "sha512-GKSNGeNAtw8IryjjkhZxuKB3JzlcLTwjtiQCHKvqQet81I93kXslhDQruGI/QsddO83mcDToBVy7GqGS/zYf/A==", + "license": "Apache-2.0" + }, + "node_modules/@injectivelabs/core-proto-ts/node_modules/protobufjs": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.2.3.tgz", + "integrity": "sha512-TtpvOqwB5Gdz/PQmOjgsrGH1nHjAQVCN7JG4A6r1sXRWESL5rNMAiRcBQlCAdKxZcAbstExQePYG8xof/JVRgg==", + "hasInstallScript": true, + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/node": ">=13.7.0", + "long": "^5.0.0" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@injectivelabs/exceptions": { + "version": "1.10.2", + "resolved": "https://registry.npmjs.org/@injectivelabs/exceptions/-/exceptions-1.10.2.tgz", + "integrity": "sha512-JLHgU/MjxRYSpn/9G9mJvHuNiA5ze6w86sXz09kQh7tlSaTC4PGqBBbBSu0hrUBBX86O+vk2ULkn1Ks1n7FlOw==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "@injectivelabs/grpc-web": "^0.0.1", + "@injectivelabs/ts-types": "^1.10.1", + "http-status-codes": "^2.2.0", + "link-module-alias": "^1.2.0", + "shx": "^0.3.2" + } + }, + "node_modules/@injectivelabs/exceptions/dist": { + "extraneous": true + }, + "node_modules/@injectivelabs/grpc-web": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/@injectivelabs/grpc-web/-/grpc-web-0.0.1.tgz", + "integrity": "sha512-Pu5YgaZp+OvR5UWfqbrPdHer3+gDf+b5fQoY+t2VZx1IAVHX8bzbN9EreYTvTYtFeDpYRWM8P7app2u4EX5wTw==", + "license": "Apache-2.0", + "dependencies": { + "browser-headers": "^0.4.1" + }, + "peerDependencies": { + "google-protobuf": "^3.14.0" + } + }, + "node_modules/@injectivelabs/grpc-web-node-http-transport": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/@injectivelabs/grpc-web-node-http-transport/-/grpc-web-node-http-transport-0.0.2.tgz", + "integrity": "sha512-rpyhXLiGY/UMs6v6YmgWHJHiO9l0AgDyVNv+jcutNVt4tQrmNvnpvz2wCAGOFtq5LuX/E9ChtTVpk3gWGqXcGA==", + "license": "Apache-2.0", + "peerDependencies": { + "@injectivelabs/grpc-web": ">=0.0.1" + } + }, + "node_modules/@injectivelabs/grpc-web-react-native-transport": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/@injectivelabs/grpc-web-react-native-transport/-/grpc-web-react-native-transport-0.0.2.tgz", + "integrity": "sha512-mk+aukQXnYNgPsPnu3KBi+FD0ZHQpazIlaBZ2jNZG7QAVmxTWtv3R66Zoq99Wx2dnE946NsZBYAoa0K5oSjnow==", + "license": "Apache-2.0", + "peerDependencies": { + "@injectivelabs/grpc-web": ">=0.0.1" + } + }, + "node_modules/@injectivelabs/indexer-proto-ts": { + "version": "0.0.9", + "resolved": "https://registry.npmjs.org/@injectivelabs/indexer-proto-ts/-/indexer-proto-ts-0.0.9.tgz", + "integrity": "sha512-ZFTUKlHAY2WYnB9RPPf11nq7SNm7wcKFTmFTavTiHV8UvNEni7dCR3Un6U5Mo1qD0xHEsfoCDMdqGcIguliPMA==", + "license": "MIT", + "dependencies": { + "@injectivelabs/grpc-web": "^0.0.1", + "google-protobuf": "^3.14.0", + "protobufjs": "^7.0.0", + "rxjs": "^7.4.0" + } + }, + "node_modules/@injectivelabs/indexer-proto-ts/node_modules/long": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/long/-/long-5.2.1.tgz", + "integrity": "sha512-GKSNGeNAtw8IryjjkhZxuKB3JzlcLTwjtiQCHKvqQet81I93kXslhDQruGI/QsddO83mcDToBVy7GqGS/zYf/A==", + "license": "Apache-2.0" + }, + "node_modules/@injectivelabs/indexer-proto-ts/node_modules/protobufjs": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.2.3.tgz", + "integrity": "sha512-TtpvOqwB5Gdz/PQmOjgsrGH1nHjAQVCN7JG4A6r1sXRWESL5rNMAiRcBQlCAdKxZcAbstExQePYG8xof/JVRgg==", + "hasInstallScript": true, + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/node": ">=13.7.0", + "long": "^5.0.0" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@injectivelabs/mito-proto-ts": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@injectivelabs/mito-proto-ts/-/mito-proto-ts-1.0.2.tgz", + "integrity": "sha512-A/5Nf/RJiBRiwYNqH2K0nNrOuuVcYCebqgEt3btpDfQXcyaHIssjDmZOtmMT1M7P/enEVgDu0auxE7tsmSFijg==", + "license": "MIT", + "dependencies": { + "@injectivelabs/grpc-web": "^0.0.1", + "google-protobuf": "^3.14.0", + "protobufjs": "^7.0.0", + "rxjs": "^7.4.0" + } + }, + "node_modules/@injectivelabs/mito-proto-ts/node_modules/long": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/long/-/long-5.2.1.tgz", + "integrity": "sha512-GKSNGeNAtw8IryjjkhZxuKB3JzlcLTwjtiQCHKvqQet81I93kXslhDQruGI/QsddO83mcDToBVy7GqGS/zYf/A==", + "license": "Apache-2.0" + }, + "node_modules/@injectivelabs/mito-proto-ts/node_modules/protobufjs": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.2.3.tgz", + "integrity": "sha512-TtpvOqwB5Gdz/PQmOjgsrGH1nHjAQVCN7JG4A6r1sXRWESL5rNMAiRcBQlCAdKxZcAbstExQePYG8xof/JVRgg==", + "hasInstallScript": true, + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/node": ">=13.7.0", + "long": "^5.0.0" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@injectivelabs/networks": { + "version": "1.10.4", + "resolved": "https://registry.npmjs.org/@injectivelabs/networks/-/networks-1.10.4.tgz", + "integrity": "sha512-EjWdTXpU+j8YFikxiMacVhPK8dzamMD4czkrst7NfcMRoBCMNMrOp5lItF5GFq0BSx3xu/zfkb2+3wWTIdWUxQ==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "@injectivelabs/exceptions": "^1.10.2", + "@injectivelabs/ts-types": "^1.10.1", + "@injectivelabs/utils": "^1.10.2", + "link-module-alias": "^1.2.0", + "shx": "^0.3.2" + } + }, + "node_modules/@injectivelabs/networks/dist": { + "extraneous": true + }, + "node_modules/@injectivelabs/sdk-ts": { + "version": "1.10.37", + "resolved": "https://registry.npmjs.org/@injectivelabs/sdk-ts/-/sdk-ts-1.10.37.tgz", + "integrity": "sha512-+7LzC1iDiN3oT7PZ3yV2PchsrH1WQfS+tV8/geesi0EBKT4AW4v2Ur3OYhtDXvQia1zSxWJY9phS3iAmaBd9vQ==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "@apollo/client": "^3.5.8", + "@cosmjs/amino": "^0.30.1", + "@cosmjs/proto-signing": "^0.30.1", + "@cosmjs/stargate": "^0.30.1", + "@ethersproject/bytes": "^5.7.0", + "@injectivelabs/core-proto-ts": "^0.0.11", + "@injectivelabs/exceptions": "^1.10.2", + "@injectivelabs/grpc-web": "^0.0.1", + "@injectivelabs/grpc-web-node-http-transport": "^0.0.2", + "@injectivelabs/grpc-web-react-native-transport": "^0.0.2", + "@injectivelabs/indexer-proto-ts": "^0.0.9", + "@injectivelabs/mito-proto-ts": "1.0.2", + "@injectivelabs/networks": "^1.10.4", + "@injectivelabs/test-utils": "^1.10.1", + "@injectivelabs/token-metadata": "^1.10.17", + "@injectivelabs/ts-types": "^1.10.1", + "@injectivelabs/utils": "^1.10.2", + "@metamask/eth-sig-util": "^4.0.0", + "axios": "^0.27.2", + "bech32": "^2.0.0", + "bip39": "^3.0.4", + "cosmjs-types": "^0.7.1", + "eth-crypto": "^2.6.0", + "ethereumjs-util": "^7.1.4", + "ethers": "^5.7.2", + "google-protobuf": "^3.21.0", + "graphql": "^16.3.0", + "http-status-codes": "^2.2.0", + "js-sha3": "^0.8.0", + "jscrypto": "^1.0.3", + "keccak256": "^1.0.6", + "link-module-alias": "^1.2.0", + "rxjs": "^7.8.0", + "secp256k1": "^4.0.3", + "shx": "^0.3.2", + "snakecase-keys": "^5.4.1" + } + }, + "node_modules/@injectivelabs/sdk-ts/dist": { + "extraneous": true + }, + "node_modules/@injectivelabs/sdk-ts/node_modules/axios": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.27.2.tgz", + "integrity": "sha512-t+yRIyySRTp/wua5xEr+z1q60QmLq8ABsS5O9Me1AsE5dfKqgnCFzwiCZZ/cGNd1lq4/7akDWMxdhVlucjmnOQ==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.14.9", + "form-data": "^4.0.0" + } + }, + "node_modules/@injectivelabs/test-utils": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/@injectivelabs/test-utils/-/test-utils-1.10.1.tgz", + "integrity": "sha512-ULP3XJBZN8Muv0jVpo0rfUOD/CDlyg4rij6YuRpYhTg6P0wIlKq9dL36cZlylay+F+4HeLn9qB0D2Cr3+FrhPw==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "axios": "^0.21.1", + "bignumber.js": "^9.0.1", + "link-module-alias": "^1.2.0", + "shx": "^0.3.2", + "snakecase-keys": "^5.1.2", + "store2": "^2.12.0" + } + }, + "node_modules/@injectivelabs/test-utils/dist": { + "extraneous": true + }, + "node_modules/@injectivelabs/token-metadata": { + "version": "1.10.17", + "resolved": "https://registry.npmjs.org/@injectivelabs/token-metadata/-/token-metadata-1.10.17.tgz", + "integrity": "sha512-1TFZMs38B21Y0uzqxRuIHifmj6VrJCZLEJnjGuhzIfhtLqSB/ZtCf3JNAarujwwgj6xWb7vzqzqNpo+SIYKvwg==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "@injectivelabs/exceptions": "^1.10.2", + "@injectivelabs/networks": "^1.10.4", + "@injectivelabs/ts-types": "^1.10.1", + "@injectivelabs/utils": "^1.10.2", + "@types/lodash.values": "^4.3.6", + "copyfiles": "^2.4.1", + "jsonschema": "^1.4.0", + "link-module-alias": "^1.2.0", + "lodash": "^4.17.21", + "lodash.values": "^4.3.0", + "shx": "^0.3.2" + } + }, + "node_modules/@injectivelabs/token-metadata/dist": { + "extraneous": true + }, + "node_modules/@injectivelabs/ts-types": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/@injectivelabs/ts-types/-/ts-types-1.10.1.tgz", + "integrity": "sha512-gQQjcnRx2TjLmZDMV8IIkRvLtAzTPptJuWKwPCfSlCRKOIv7Eafzy2qFINUIkKDOeu/lZUtSykEsAIUBEmXqFg==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "link-module-alias": "^1.2.0", + "shx": "^0.3.2" + } + }, + "node_modules/@injectivelabs/ts-types/dist": { + "extraneous": true + }, + "node_modules/@injectivelabs/utils": { + "version": "1.10.2", + "resolved": "https://registry.npmjs.org/@injectivelabs/utils/-/utils-1.10.2.tgz", + "integrity": "sha512-XMO7RRbXs06cChr5Wezr0Dbl1Z9hq+ceB4Dn3qyulzupGepeivkoPTcyG4IdjOiwf7PnFeGQ/aVG3hr0rJI7dQ==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "@injectivelabs/exceptions": "^1.10.2", + "@injectivelabs/ts-types": "^1.10.1", + "axios": "^0.21.1", + "bignumber.js": "^9.0.1", + "http-status-codes": "^2.2.0", + "link-module-alias": "^1.2.0", + "shx": "^0.3.2", + "snakecase-keys": "^5.1.2", + "store2": "^2.12.0" + } + }, + "node_modules/@injectivelabs/utils/dist": { + "extraneous": true + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz", + "integrity": "sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.9", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz", + "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==", + "dependencies": { + "@jridgewell/resolve-uri": "^3.0.3", + "@jridgewell/sourcemap-codec": "^1.4.10" + } + }, + "node_modules/@metamask/eth-sig-util": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@metamask/eth-sig-util/-/eth-sig-util-4.0.1.tgz", + "integrity": "sha512-tghyZKLHZjcdlDqCA3gNZmLeR0XvOE9U1qoQO9ohyAZT6Pya+H9vkBPcsyXytmYLNgVoin7CKCmweo/R43V+tQ==", + "license": "ISC", + "dependencies": { + "ethereumjs-abi": "^0.6.8", + "ethereumjs-util": "^6.2.1", + "ethjs-util": "^0.1.6", + "tweetnacl": "^1.0.3", + "tweetnacl-util": "^0.15.1" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@metamask/eth-sig-util/node_modules/@types/bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@metamask/eth-sig-util/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "license": "MIT" + }, + "node_modules/@metamask/eth-sig-util/node_modules/ethereumjs-util": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-6.2.1.tgz", + "integrity": "sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw==", + "license": "MPL-2.0", + "dependencies": { + "@types/bn.js": "^4.11.3", + "bn.js": "^4.11.0", + "create-hash": "^1.1.2", + "elliptic": "^6.5.2", + "ethereum-cryptography": "^0.1.3", + "ethjs-util": "0.1.6", + "rlp": "^2.2.3" + } + }, + "node_modules/@mysten/bcs": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/@mysten/bcs/-/bcs-0.7.1.tgz", + "integrity": "sha512-wFPb8bkhwrbiStfZMV5rFM7J+umpke59/dNjDp+UYJKykNlW23LCk2ePyEUvGdb62HGJM1jyOJ8g4egE3OmdKA==", + "license": "Apache-2.0", + "dependencies": { + "bs58": "^5.0.0" + } + }, + "node_modules/@mysten/bcs/node_modules/base-x": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-4.0.0.tgz", + "integrity": "sha512-FuwxlW4H5kh37X/oW59pwTzzTKRzfrrQwhmyspRM7swOEZcHtDZSCt45U6oKgtuFE+WYPblePMVIPR4RZrh/hw==", + "license": "MIT" + }, + "node_modules/@mysten/bcs/node_modules/bs58": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-5.0.0.tgz", + "integrity": "sha512-r+ihvQJvahgYT50JD05dyJNKlmmSlMoOGwn1lCcEzanPglg7TxYjioQUYehQ9mAR/+hOSd2jRc/Z2y5UxBymvQ==", + "license": "MIT", + "dependencies": { + "base-x": "^4.0.0" + } + }, + "node_modules/@mysten/sui.js": { + "version": "0.32.2", + "resolved": "https://registry.npmjs.org/@mysten/sui.js/-/sui.js-0.32.2.tgz", + "integrity": "sha512-/Hm4xkGolJhqj8FvQr7QSHDTlxIvL52mtbOao9f75YjrBh7y1Uh9kbJSY7xiTF1NY9sv6p5hUVlYRJuM0Hvn9A==", + "license": "Apache-2.0", + "dependencies": { + "@mysten/bcs": "0.7.1", + "@noble/curves": "^1.0.0", + "@noble/hashes": "^1.3.0", + "@scure/bip32": "^1.3.0", + "@scure/bip39": "^1.2.0", + "@suchipi/femver": "^1.0.0", + "jayson": "^4.0.0", + "rpc-websockets": "^7.5.1", + "superstruct": "^1.0.3", + "tweetnacl": "^1.0.3" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/@noble/curves": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.0.0.tgz", + "integrity": "sha512-2upgEu0iLiDVDZkNLeFV2+ht0BAVgQnEmCk6JsOch9Rp8xfkMCbvbAZlA2pBHQc73dbl+vFOXfqkf4uemdn0bw==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT", + "dependencies": { + "@noble/hashes": "1.3.0" + } + }, + "node_modules/@noble/ed25519": { + "version": "1.7.3", + "resolved": "https://registry.npmjs.org/@noble/ed25519/-/ed25519-1.7.3.tgz", + "integrity": "sha512-iR8GBkDt0Q3GyaVcIu7mSsVIqnFbkbRzGLWlvhwunacoLwt4J3swfKhfaM6rN6WY+TBGoYT1GtT1mIh2/jGbRQ==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT" + }, + "node_modules/@noble/hashes": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.3.0.tgz", + "integrity": "sha512-ilHEACi9DwqJB0pw7kv+Apvh50jiiSyR/cQ3y4W7lOR5mhvn/50FLUfsnfJz0BDZtl/RR16kXvptiv6q1msYZg==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT" + }, + "node_modules/@noble/secp256k1": { + "version": "1.7.1", + "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-1.7.1.tgz", + "integrity": "sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT" + }, + "node_modules/@project-serum/anchor": { + "version": "0.25.0", + "resolved": "https://registry.npmjs.org/@project-serum/anchor/-/anchor-0.25.0.tgz", + "integrity": "sha512-E6A5Y/ijqpfMJ5psJvbw0kVTzLZFUcOFgs6eSM2M2iWE1lVRF18T6hWZVNl6zqZsoz98jgnNHtVGJMs+ds9A7A==", + "license": "(MIT OR Apache-2.0)", + "dependencies": { + "@project-serum/borsh": "^0.2.5", + "@solana/web3.js": "^1.36.0", + "base64-js": "^1.5.1", + "bn.js": "^5.1.2", + "bs58": "^4.0.1", + "buffer-layout": "^1.2.2", + "camelcase": "^5.3.1", + "cross-fetch": "^3.1.5", + "crypto-hash": "^1.3.0", + "eventemitter3": "^4.0.7", + "js-sha256": "^0.9.0", + "pako": "^2.0.3", + "snake-case": "^3.0.4", + "superstruct": "^0.15.4", + "toml": "^3.0.0" + }, + "engines": { + "node": ">=11" + } + }, + "node_modules/@project-serum/anchor/node_modules/superstruct": { + "version": "0.15.5", + "resolved": "https://registry.npmjs.org/superstruct/-/superstruct-0.15.5.tgz", + "integrity": "sha512-4AOeU+P5UuE/4nOUkmcQdW5y7i9ndt1cQd/3iUe+LTz3RxESf/W/5lg4B74HbDMMv8PHnPnGCQFH45kBcrQYoQ==", + "license": "MIT" + }, + "node_modules/@project-serum/borsh": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/@project-serum/borsh/-/borsh-0.2.5.tgz", + "integrity": "sha512-UmeUkUoKdQ7rhx6Leve1SssMR/Ghv8qrEiyywyxSWg7ooV7StdpPBhciiy5eB3T0qU1BXvdRNC8TdrkxK7WC5Q==", + "license": "Apache-2.0", + "dependencies": { + "bn.js": "^5.1.2", + "buffer-layout": "^1.2.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "@solana/web3.js": "^1.2.0" + } + }, + "node_modules/@protobufjs/aspromise": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz", + "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/base64": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz", + "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/codegen": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz", + "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/eventemitter": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz", + "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/fetch": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz", + "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==", + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.1", + "@protobufjs/inquire": "^1.1.0" + } + }, + "node_modules/@protobufjs/float": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz", + "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/inquire": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz", + "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/path": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz", + "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/pool": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz", + "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/utf8": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz", + "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==", + "license": "BSD-3-Clause" + }, + "node_modules/@scure/base": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.1.1.tgz", + "integrity": "sha512-ZxOhsSyxYwLJj3pLZCefNitxsj093tb2vq90mp2txoYeBqbcjDjqFhyM8eUjq/uFm6zJ+mUuqxlS2FkuSY1MTA==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT" + }, + "node_modules/@scure/bip32": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@scure/bip32/-/bip32-1.3.0.tgz", + "integrity": "sha512-bcKpo1oj54hGholplGLpqPHRbIsnbixFtc06nwuNM5/dwSXOq/AAYoIBRsBmnZJSdfeNW5rnff7NTAz3ZCqR9Q==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT", + "dependencies": { + "@noble/curves": "~1.0.0", + "@noble/hashes": "~1.3.0", + "@scure/base": "~1.1.0" + } + }, + "node_modules/@scure/bip39": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.2.0.tgz", + "integrity": "sha512-SX/uKq52cuxm4YFXWFaVByaSHJh2w3BnokVSeUJVCv6K7WulT9u2BuNRBhuFl8vAuYnzx9bEu9WgpcNYTrYieg==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT", + "dependencies": { + "@noble/hashes": "~1.3.0", + "@scure/base": "~1.1.0" + } + }, + "node_modules/@solana/buffer-layout": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@solana/buffer-layout/-/buffer-layout-4.0.1.tgz", + "integrity": "sha512-E1ImOIAD1tBZFRdjeM4/pzTiTApC0AOBGwyAMS4fwIodCWArzJ3DWdoh8cKxeFM2fElkxBh2Aqts1BPC373rHA==", + "license": "MIT", + "dependencies": { + "buffer": "~6.0.3" + }, + "engines": { + "node": ">=5.10" + } + }, + "node_modules/@solana/buffer-layout-utils": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/@solana/buffer-layout-utils/-/buffer-layout-utils-0.2.0.tgz", + "integrity": "sha512-szG4sxgJGktbuZYDg2FfNmkMi0DYQoVjN2h7ta1W1hPrwzarcFLBq9UpX1UjNXsNpT9dn+chgprtWGioUAr4/g==", + "license": "Apache-2.0", + "dependencies": { + "@solana/buffer-layout": "^4.0.0", + "@solana/web3.js": "^1.32.0", + "bigint-buffer": "^1.1.5", + "bignumber.js": "^9.0.1" + }, + "engines": { + "node": ">= 10" + } + }, + "node_modules/@solana/spl-token": { + "version": "0.3.7", + "resolved": "https://registry.npmjs.org/@solana/spl-token/-/spl-token-0.3.7.tgz", + "integrity": "sha512-bKGxWTtIw6VDdCBngjtsGlKGLSmiu/8ghSt/IOYJV24BsymRbgq7r12GToeetpxmPaZYLddKwAz7+EwprLfkfg==", + "license": "Apache-2.0", + "dependencies": { + "@solana/buffer-layout": "^4.0.0", + "@solana/buffer-layout-utils": "^0.2.0", + "buffer": "^6.0.3" + }, + "engines": { + "node": ">=16" + }, + "peerDependencies": { + "@solana/web3.js": "^1.47.4" + } + }, + "node_modules/@solana/web3.js": { + "version": "1.75.0", + "resolved": "https://registry.npmjs.org/@solana/web3.js/-/web3.js-1.75.0.tgz", + "integrity": "sha512-rHQgdo1EWfb+nPUpHe4O7i8qJPELHKNR5PAZRK+a7XxiykqOfbaAlPt5boDWAGPnYbSv0ziWZv5mq9DlFaQCxg==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.12.5", + "@noble/ed25519": "^1.7.0", + "@noble/hashes": "^1.1.2", + "@noble/secp256k1": "^1.6.3", + "@solana/buffer-layout": "^4.0.0", + "agentkeepalive": "^4.2.1", + "bigint-buffer": "^1.1.5", + "bn.js": "^5.0.0", + "borsh": "^0.7.0", + "bs58": "^4.0.1", + "buffer": "6.0.3", + "fast-stable-stringify": "^1.0.0", + "jayson": "^3.4.4", + "node-fetch": "^2.6.7", + "rpc-websockets": "^7.5.1", + "superstruct": "^0.14.2" + } + }, + "node_modules/@solana/web3.js/node_modules/@types/node": { + "version": "12.20.55", + "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.55.tgz", + "integrity": "sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==", + "license": "MIT" + }, + "node_modules/@solana/web3.js/node_modules/jayson": { + "version": "3.7.0", + "resolved": "https://registry.npmjs.org/jayson/-/jayson-3.7.0.tgz", + "integrity": "sha512-tfy39KJMrrXJ+mFcMpxwBvFDetS8LAID93+rycFglIQM4kl3uNR3W4lBLE/FFhsoUCEox5Dt2adVpDm/XtebbQ==", + "license": "MIT", + "dependencies": { + "@types/connect": "^3.4.33", + "@types/node": "^12.12.54", + "@types/ws": "^7.4.4", + "commander": "^2.20.3", + "delay": "^5.0.0", + "es6-promisify": "^5.0.0", + "eyes": "^0.1.8", + "isomorphic-ws": "^4.0.1", + "json-stringify-safe": "^5.0.1", + "JSONStream": "^1.3.5", + "lodash": "^4.17.20", + "uuid": "^8.3.2", + "ws": "^7.4.5" + }, + "bin": { + "jayson": "bin/jayson.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@solana/web3.js/node_modules/superstruct": { + "version": "0.14.2", + "resolved": "https://registry.npmjs.org/superstruct/-/superstruct-0.14.2.tgz", + "integrity": "sha512-nPewA6m9mR3d6k7WkZ8N8zpTWfenFH3q9pA2PkuiZxINr9DKB2+40wEQf0ixn8VaGuJ78AB6iWOtStI+/4FKZQ==", + "license": "MIT" + }, + "node_modules/@suchipi/femver": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@suchipi/femver/-/femver-1.0.0.tgz", + "integrity": "sha512-bprE8+K5V+DPX7q2e2K57ImqNBdfGHDIWaGI5xHxZoxbKOuQZn4wzPiUxOAHnsUr3w3xHrWXwN7gnG/iIuEMIg==", + "license": "MIT" + }, + "node_modules/@terra-money/legacy.proto": { + "name": "@terra-money/terra.proto", + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/@terra-money/terra.proto/-/terra.proto-0.1.7.tgz", + "integrity": "sha512-NXD7f6pQCulvo6+mv6MAPzhOkUzRjgYVuHZE/apih+lVnPG5hDBU0rRYnOGGofwvKT5/jQoOENnFn/gioWWnyQ==", + "license": "Apache-2.0", + "dependencies": { + "google-protobuf": "^3.17.3", + "long": "^4.0.0", + "protobufjs": "~6.11.2" + } + }, + "node_modules/@terra-money/terra.js": { + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/@terra-money/terra.js/-/terra.js-3.1.8.tgz", + "integrity": "sha512-Cd/fh4MswT00fDGVckoZ0cm77EpIy4+CjSDO0RqZ3Qfp4CJBp7sWTLRNsyzUWjdYOT5iTx+1wOMCYbbyKo6LAw==", + "license": "MIT", + "dependencies": { + "@classic-terra/terra.proto": "^1.1.0", + "@terra-money/terra.proto": "^2.1.0", + "axios": "^0.27.2", + "bech32": "^2.0.0", + "bip32": "^2.0.6", + "bip39": "^3.0.3", + "bufferutil": "^4.0.3", + "decimal.js": "^10.2.1", + "jscrypto": "^1.0.1", + "readable-stream": "^3.6.0", + "secp256k1": "^4.0.2", + "tmp": "^0.2.1", + "utf-8-validate": "^5.0.5", + "ws": "^7.5.9" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@terra-money/terra.js/node_modules/axios": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.27.2.tgz", + "integrity": "sha512-t+yRIyySRTp/wua5xEr+z1q60QmLq8ABsS5O9Me1AsE5dfKqgnCFzwiCZZ/cGNd1lq4/7akDWMxdhVlucjmnOQ==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.14.9", + "form-data": "^4.0.0" + } + }, + "node_modules/@terra-money/terra.proto": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@terra-money/terra.proto/-/terra.proto-2.1.0.tgz", + "integrity": "sha512-rhaMslv3Rkr+QsTQEZs64FKA4QlfO0DfQHaR6yct/EovenMkibDEQ63dEL6yJA6LCaEQGYhyVB9JO9pTUA8ybw==", + "license": "Apache-2.0", + "dependencies": { + "@improbable-eng/grpc-web": "^0.14.1", + "google-protobuf": "^3.17.3", + "long": "^4.0.0", + "protobufjs": "~6.11.2" + } + }, + "node_modules/@tsconfig/node10": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz", + "integrity": "sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==" + }, + "node_modules/@tsconfig/node12": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz", + "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==" + }, + "node_modules/@tsconfig/node14": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz", + "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==" + }, + "node_modules/@tsconfig/node16": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.3.tgz", + "integrity": "sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ==" + }, + "node_modules/@types/bn.js": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.1.tgz", + "integrity": "sha512-qNrYbZqMx0uJAfKnKclPh+dTwK33KfLHYqtyODwd5HnXOjnkhc4qgn3BrK6RWyGZm5+sIFE7Q7Vz6QQtJB7w7g==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/chai": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.4.tgz", + "integrity": "sha512-KnRanxnpfpjUTqTCXslZSEdLfXExwgNxYPdiO2WGUj8+HDjFi8R3k5RVKPeSCzLjCcshCAtVO2QBbVuAV4kTnw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/connect": { + "version": "3.4.35", + "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.35.tgz", + "integrity": "sha512-cdeYyv4KWoEgpBISTxWvqYsVy444DOqehiF3fM3ne10AmJ62RSyNkUnxMJXHQWRQQX2eR94m5y1IZyDwBjV9FQ==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/json5": { + "version": "0.0.29", + "resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz", + "integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==", + "license": "MIT", + "optional": true + }, + "node_modules/@types/lodash": { + "version": "4.14.192", + "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.192.tgz", + "integrity": "sha512-km+Vyn3BYm5ytMO13k9KTp27O75rbQ0NFw+U//g+PX7VZyjCioXaRFisqSIJRECljcTv73G3i6BpglNGHgUQ5A==", + "license": "MIT" + }, + "node_modules/@types/lodash.values": { + "version": "4.3.7", + "resolved": "https://registry.npmjs.org/@types/lodash.values/-/lodash.values-4.3.7.tgz", + "integrity": "sha512-Moex9/sWxtKEa+BKiH5zvmhfcieDlcz4wRxMhO/oJ2qOKUdujoU6dQjUTxWA8jwEREpHXmiY4HCwNRpycW8JQA==", + "license": "MIT", + "dependencies": { + "@types/lodash": "*" + } + }, + "node_modules/@types/long": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/long/-/long-4.0.2.tgz", + "integrity": "sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA==", + "license": "MIT" + }, + "node_modules/@types/mocha": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.1.tgz", + "integrity": "sha512-/fvYntiO1GeICvqbQ3doGDIP97vWmvFt83GKguJ6prmQM2iXZfFcq6YE8KteFyRtX2/h5Hf91BYvPodJKFYv5Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "18.15.11", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.15.11.tgz", + "integrity": "sha512-E5Kwq2n4SbMzQOn6wnmBjuK9ouqlURrcZDVfbo9ftDDTFt3nk7ZKK4GMOzoYgnpQJKcxwQw+lGaBvvlMo0qN/Q==", + "license": "MIT" + }, + "node_modules/@types/pbkdf2": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@types/pbkdf2/-/pbkdf2-3.1.0.tgz", + "integrity": "sha512-Cf63Rv7jCQ0LaL8tNXmEyqTHuIJxRdlS5vMh1mj5voN4+QFhVZnlZruezqpWYDiJ8UTzhP0VmeLXCmBk66YrMQ==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/secp256k1": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/@types/secp256k1/-/secp256k1-4.0.3.tgz", + "integrity": "sha512-Da66lEIFeIz9ltsdMZcpQvmrmmoqrfju8pm1BH8WbYjZSwUgCwXLb9C+9XYogwBITnbsSaMdVPb2ekf7TV+03w==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/ws": { + "version": "7.4.7", + "resolved": "https://registry.npmjs.org/@types/ws/-/ws-7.4.7.tgz", + "integrity": "sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@wry/context": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/@wry/context/-/context-0.7.0.tgz", + "integrity": "sha512-LcDAiYWRtwAoSOArfk7cuYvFXytxfVrdX7yxoUmK7pPITLk5jYh2F8knCwS7LjgYL8u1eidPlKKV6Ikqq0ODqQ==", + "license": "MIT", + "dependencies": { + "tslib": "^2.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@wry/equality": { + "version": "0.5.3", + "resolved": "https://registry.npmjs.org/@wry/equality/-/equality-0.5.3.tgz", + "integrity": "sha512-avR+UXdSrsF2v8vIqIgmeTY0UR91UT+IyablCyKe/uk22uOJ8fusKZnH9JH9e1/EtLeNJBtagNmL3eJdnOV53g==", + "license": "MIT", + "dependencies": { + "tslib": "^2.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@wry/trie": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/@wry/trie/-/trie-0.3.2.tgz", + "integrity": "sha512-yRTyhWSls2OY/pYLfwff867r8ekooZ4UI+/gxot5Wj8EFwSf2rG+n+Mo/6LoLQm1TKA4GRj2+LCpbfS937dClQ==", + "license": "MIT", + "dependencies": { + "tslib": "^2.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@xpla/xpla.js": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@xpla/xpla.js/-/xpla.js-0.2.3.tgz", + "integrity": "sha512-Tfk7hCGWXtwr08reY3Pi6dmzIqFbzri9jcyzJdfNmdo4cN0PMwpRJuZZcPmtxiIUnNef3AN1E/6nJUD5MKniuA==", + "license": "MIT", + "dependencies": { + "@ethersproject/bytes": "^5.6.1", + "@ethersproject/keccak256": "^5.6.1", + "@ethersproject/signing-key": "^5.6.2", + "@terra-money/legacy.proto": "npm:@terra-money/terra.proto@^0.1.7", + "@terra-money/terra.proto": "^2.1.0", + "axios": "^0.26.1", + "bech32": "^2.0.0", + "bip32": "^2.0.6", + "bip39": "^3.0.3", + "bufferutil": "^4.0.3", + "crypto-addr-codec": "^0.1.7", + "decimal.js": "^10.2.1", + "elliptic": "^6.5.4", + "ethereumjs-util": "^7.1.5", + "jscrypto": "^1.0.1", + "readable-stream": "^3.6.0", + "secp256k1": "^4.0.2", + "tmp": "^0.2.1", + "utf-8-validate": "^5.0.5", + "ws": "^7.5.8" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@xpla/xpla.js/node_modules/axios": { + "version": "0.26.1", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.26.1.tgz", + "integrity": "sha512-fPwcX4EvnSHuInCMItEhAGnaSEXRBjtzh9fOtsE6E1G6p7vl7edEeZe11QHf18+6+9gR5PbKV/sGKNaD8YaMeA==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.14.8" + } + }, + "node_modules/acorn": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.1.1.tgz", + "integrity": "sha512-add7dgA5ppRPxCFJoAGfMDi7PIBXq1RtGo7BhbLaxwrXPOmw8gq48Y9ozT01hUKy9byMjlR20EJhu5zlkErEkg==", + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-walk": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz", + "integrity": "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/aes-js": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-3.0.0.tgz", + "integrity": "sha512-H7wUZRn8WpTq9jocdxQ2c8x2sKo9ZVmzfRE13GiNJXfp7NcKYEdvl3vspKjXox6RIG2VtaRe4JFvxG4rqp2Zuw==", + "license": "MIT" + }, + "node_modules/agentkeepalive": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.3.0.tgz", + "integrity": "sha512-7Epl1Blf4Sy37j4v9f9FjICCh4+KAQOyXgHEwlyBiAQLbhKdq/i2QQU3amQalS/wPhdPzDXPL5DMR5bkn+YeWg==", + "license": "MIT", + "dependencies": { + "debug": "^4.1.0", + "depd": "^2.0.0", + "humanize-ms": "^1.2.1" + }, + "engines": { + "node": ">= 8.0.0" + } + }, + "node_modules/algo-msgpack-with-bigint": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/algo-msgpack-with-bigint/-/algo-msgpack-with-bigint-2.1.1.tgz", + "integrity": "sha512-F1tGh056XczEaEAqu7s+hlZUDWwOBT70Eq0lfMpBP2YguSQVyxRbprLq5rELXKQOyOaixTWYhMeMQMzP0U5FoQ==", + "license": "ISC", + "engines": { + "node": ">= 10" + } + }, + "node_modules/algosdk": { + "version": "1.24.1", + "resolved": "https://registry.npmjs.org/algosdk/-/algosdk-1.24.1.tgz", + "integrity": "sha512-9moZxdqeJ6GdE4N6fA/GlUP4LrbLZMYcYkt141J4Ss68OfEgH9qW0wBuZ3ZOKEx/xjc5bg7mLP2Gjg7nwrkmww==", + "license": "MIT", + "dependencies": { + "algo-msgpack-with-bigint": "^2.1.1", + "buffer": "^6.0.2", + "cross-fetch": "^3.1.5", + "hi-base32": "^0.5.1", + "js-sha256": "^0.9.0", + "js-sha3": "^0.8.0", + "js-sha512": "^0.8.0", + "json-bigint": "^1.0.0", + "tweetnacl": "^1.0.3", + "vlq": "^2.0.4" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/ansi-colors": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz", + "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "license": "ISC", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/aptos": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/aptos/-/aptos-1.5.0.tgz", + "integrity": "sha512-N7OuRtU7IYHkDkNx+4QS3g/QQGCp+36KzYn3oXPmT7Kttfuv+UKliQVdjy3cLmwd/DCQSh9ObTovwdxnHjUn0g==", + "license": "Apache-2.0", + "dependencies": { + "@noble/hashes": "1.1.3", + "@scure/bip39": "1.1.0", + "axios": "0.27.2", + "form-data": "4.0.0", + "tweetnacl": "1.0.3" + }, + "engines": { + "node": ">=11.0.0" + } + }, + "node_modules/aptos/node_modules/@noble/hashes": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.1.3.tgz", + "integrity": "sha512-CE0FCR57H2acVI5UOzIGSSIYxZ6v/HOhDR0Ro9VLyhnzLwx0o8W1mmgaqlEUx4049qJDlIBRztv5k+MM8vbO3A==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT" + }, + "node_modules/aptos/node_modules/@scure/bip39": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.1.0.tgz", + "integrity": "sha512-pwrPOS16VeTKg98dYXQyIjJEcWfz7/1YJIwxUEPFfQPtc86Ym/1sVgQ2RLoD43AazMk2l/unK4ITySSpW2+82w==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT", + "dependencies": { + "@noble/hashes": "~1.1.1", + "@scure/base": "~1.1.0" + } + }, + "node_modules/aptos/node_modules/@scure/bip39/node_modules/@noble/hashes": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.1.5.tgz", + "integrity": "sha512-LTMZiiLc+V4v1Yi16TD6aX2gmtKszNye0pQgbaLqkvhIqP7nVsSaJsWloGQjJfJ8offaoP5GtX3yY5swbcJxxQ==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT" + }, + "node_modules/aptos/node_modules/axios": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.27.2.tgz", + "integrity": "sha512-t+yRIyySRTp/wua5xEr+z1q60QmLq8ABsS5O9Me1AsE5dfKqgnCFzwiCZZ/cGNd1lq4/7akDWMxdhVlucjmnOQ==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.14.9", + "form-data": "^4.0.0" + } + }, + "node_modules/arg": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz", + "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==" + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "license": "Python-2.0" + }, + "node_modules/arrify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz", + "integrity": "sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/assertion-error": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz", + "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "license": "MIT" + }, + "node_modules/axios": { + "version": "0.21.4", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.21.4.tgz", + "integrity": "sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.14.0" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "license": "MIT" + }, + "node_modules/base-x": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-3.0.9.tgz", + "integrity": "sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ==", + "license": "MIT", + "dependencies": { + "safe-buffer": "^5.0.1" + } + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/bech32": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/bech32/-/bech32-2.0.0.tgz", + "integrity": "sha512-LcknSilhIGatDAsY1ak2I8VtGaHNhgMSYVxFrGLXv+xLHytaKZKcaUJJUE7qmBr7h33o5YQwP55pMI0xmkpJwg==", + "license": "MIT" + }, + "node_modules/big-integer": { + "version": "1.6.36", + "resolved": "https://registry.npmjs.org/big-integer/-/big-integer-1.6.36.tgz", + "integrity": "sha512-t70bfa7HYEA1D9idDbmuv7YbsbVkQ+Hp+8KFSul4aE5e/i1bjCNIRYJZlA8Q8p0r9T8cF/RVvwUgRA//FydEyg==", + "license": "Unlicense", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/bigint-buffer": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/bigint-buffer/-/bigint-buffer-1.1.5.tgz", + "integrity": "sha512-trfYco6AoZ+rKhKnxA0hgX0HAbVP/s808/EuDSe2JDzUnCp/xAsli35Orvk67UrTEcwuxZqYZDmfA2RXJgxVvA==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "bindings": "^1.3.0" + }, + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/bignumber.js": { + "version": "9.1.1", + "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.1.1.tgz", + "integrity": "sha512-pHm4LsMJ6lzgNGVfZHjMoO8sdoRhOzOH4MLmY65Jg70bpxCKu5iOHNJyfF6OyvYw7t8Fpf35RuzUyqnQsj8Vig==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/binary-extensions": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", + "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/binary-parser": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/binary-parser/-/binary-parser-2.2.1.tgz", + "integrity": "sha512-5ATpz/uPDgq5GgEDxTB4ouXCde7q2lqAQlSdBRQVl/AJnxmQmhIfyxJx+0MGu//D5rHQifkfGbWWlaysG0o9NA==", + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/bindings": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz", + "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==", + "license": "MIT", + "dependencies": { + "file-uri-to-path": "1.0.0" + } + }, + "node_modules/bip32": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/bip32/-/bip32-2.0.6.tgz", + "integrity": "sha512-HpV5OMLLGTjSVblmrtYRfFFKuQB+GArM0+XP8HGWfJ5vxYBqo+DesvJwOdC2WJ3bCkZShGf0QIfoIpeomVzVdA==", + "license": "MIT", + "dependencies": { + "@types/node": "10.12.18", + "bs58check": "^2.1.1", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "tiny-secp256k1": "^1.1.3", + "typeforce": "^1.11.5", + "wif": "^2.0.6" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/bip32/node_modules/@types/node": { + "version": "10.12.18", + "resolved": "https://registry.npmjs.org/@types/node/-/node-10.12.18.tgz", + "integrity": "sha512-fh+pAqt4xRzPfqA6eh3Z2y6fyZavRIumvjhaCL753+TVkGKGhpPeyrJG2JftD0T9q4GF00KjefsQ+PQNDdWQaQ==", + "license": "MIT" + }, + "node_modules/bip39": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/bip39/-/bip39-3.1.0.tgz", + "integrity": "sha512-c9kiwdk45Do5GL0vJMe7tS95VjCii65mYAH7DfWl3uW8AVzXKQVUm64i3hzVybBDMp9r7j9iNxR85+ul8MdN/A==", + "license": "ISC", + "dependencies": { + "@noble/hashes": "^1.2.0" + } + }, + "node_modules/bip66": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/bip66/-/bip66-1.1.5.tgz", + "integrity": "sha512-nemMHz95EmS38a26XbbdxIYj5csHd3RMP3H5bwQknX0WYHF01qhpufP42mLOwVICuH2JmhIhXiWs89MfUGL7Xw==", + "license": "MIT", + "optional": true, + "dependencies": { + "safe-buffer": "^5.0.1" + } + }, + "node_modules/blakejs": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/blakejs/-/blakejs-1.2.1.tgz", + "integrity": "sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==", + "license": "MIT" + }, + "node_modules/bn.js": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz", + "integrity": "sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==", + "license": "MIT" + }, + "node_modules/borsh": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/borsh/-/borsh-0.7.0.tgz", + "integrity": "sha512-CLCsZGIBCFnPtkNnieW/a8wmreDmfUtjU2m9yHrzPXIlNbqVs0AQrSatSG6vdNYUqdc83tkQi2eHfF98ubzQLA==", + "license": "Apache-2.0", + "dependencies": { + "bn.js": "^5.2.0", + "bs58": "^4.0.0", + "text-encoding-utf-8": "^1.0.2" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "license": "MIT", + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==", + "license": "MIT" + }, + "node_modules/browser-headers": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/browser-headers/-/browser-headers-0.4.1.tgz", + "integrity": "sha512-CA9hsySZVo9371qEHjHZtYxV2cFtVj5Wj/ZHi8ooEsrtm4vOnl9Y9HmyYWk9q+05d7K3rdoAE0j3MVEFVvtQtg==", + "license": "Apache-2.0" + }, + "node_modules/browser-stdout": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz", + "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==", + "license": "ISC" + }, + "node_modules/browserify-aes": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz", + "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", + "license": "MIT", + "dependencies": { + "buffer-xor": "^1.0.3", + "cipher-base": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.3", + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "node_modules/bs58": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-4.0.1.tgz", + "integrity": "sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==", + "license": "MIT", + "dependencies": { + "base-x": "^3.0.2" + } + }, + "node_modules/bs58check": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/bs58check/-/bs58check-2.1.2.tgz", + "integrity": "sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==", + "license": "MIT", + "dependencies": { + "bs58": "^4.0.0", + "create-hash": "^1.1.0", + "safe-buffer": "^5.1.2" + } + }, + "node_modules/buffer": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", + "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==" + }, + "node_modules/buffer-layout": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/buffer-layout/-/buffer-layout-1.2.2.tgz", + "integrity": "sha512-kWSuLN694+KTk8SrYvCqwP2WcgQjoRCiF5b4QDvkkz8EmgD+aWAIceGFKMIAdmF/pH+vpgNV3d3kAKorcdAmWA==", + "license": "MIT", + "engines": { + "node": ">=4.5" + } + }, + "node_modules/buffer-xor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", + "integrity": "sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==", + "license": "MIT" + }, + "node_modules/bufferutil": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/bufferutil/-/bufferutil-4.0.7.tgz", + "integrity": "sha512-kukuqc39WOHtdxtw4UScxF/WVnMFVSQVKhtx3AjZJzhd0RGZZldcrfSEbVsWWe6KNH253574cq5F+wpv0G9pJw==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "node-gyp-build": "^4.3.0" + }, + "engines": { + "node": ">=6.14.2" + } + }, + "node_modules/camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/capability": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/capability/-/capability-0.2.5.tgz", + "integrity": "sha512-rsJZYVCgXd08sPqwmaIqjAd5SUTfonV0z/gDJ8D6cN8wQphky1kkAYEqQ+hmDxTw7UihvBfjUVUSY+DBEe44jg==", + "license": "MIT" + }, + "node_modules/chai": { + "version": "4.3.7", + "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.7.tgz", + "integrity": "sha512-HLnAzZ2iupm25PlN0xFreAlBA5zaBSv3og0DdeGA4Ar6h6rJ3A0rolRUKJhSF2V10GZKDgWF/VmAEsNWjCRB+A==", + "license": "MIT", + "dependencies": { + "assertion-error": "^1.1.0", + "check-error": "^1.0.2", + "deep-eql": "^4.1.2", + "get-func-name": "^2.0.0", + "loupe": "^2.3.1", + "pathval": "^1.1.1", + "type-detect": "^4.0.5" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/chalk/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/check-error": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz", + "integrity": "sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/chokidar": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", + "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "license": "MIT", + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "node_modules/cliui": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", + "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", + "license": "ISC", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^7.0.0" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "license": "MIT" + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "license": "MIT", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "license": "MIT" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "license": "MIT" + }, + "node_modules/copyfiles": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/copyfiles/-/copyfiles-2.4.1.tgz", + "integrity": "sha512-fereAvAvxDrQDOXybk3Qu3dPbOoKoysFMWtkY3mv5BsL8//OSZVL5DCLYqgRfY5cWirgRzlC+WSrxp6Bo3eNZg==", + "license": "MIT", + "dependencies": { + "glob": "^7.0.5", + "minimatch": "^3.0.3", + "mkdirp": "^1.0.4", + "noms": "0.0.0", + "through2": "^2.0.1", + "untildify": "^4.0.0", + "yargs": "^16.1.0" + }, + "bin": { + "copyfiles": "copyfiles", + "copyup": "copyfiles" + } + }, + "node_modules/copyfiles/node_modules/mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "license": "MIT", + "bin": { + "mkdirp": "bin/cmd.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/core-util-is": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz", + "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==", + "license": "MIT" + }, + "node_modules/cosmjs-types": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cosmjs-types/-/cosmjs-types-0.7.2.tgz", + "integrity": "sha512-vf2uLyktjr/XVAgEq0DjMxeAWh1yYREe7AMHDKd7EiHVqxBPCaBS+qEEQUkXbR9ndnckqr1sUG8BQhazh4X5lA==", + "license": "Apache-2.0", + "dependencies": { + "long": "^4.0.0", + "protobufjs": "~6.11.2" + } + }, + "node_modules/crc-32": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz", + "integrity": "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==", + "license": "Apache-2.0", + "bin": { + "crc32": "bin/crc32.njs" + }, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/create-hash": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", + "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", + "license": "MIT", + "dependencies": { + "cipher-base": "^1.0.1", + "inherits": "^2.0.1", + "md5.js": "^1.3.4", + "ripemd160": "^2.0.1", + "sha.js": "^2.4.0" + } + }, + "node_modules/create-hmac": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", + "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", + "license": "MIT", + "dependencies": { + "cipher-base": "^1.0.3", + "create-hash": "^1.1.0", + "inherits": "^2.0.1", + "ripemd160": "^2.0.0", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "node_modules/create-require": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz", + "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==" + }, + "node_modules/cross-fetch": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/cross-fetch/-/cross-fetch-3.1.5.tgz", + "integrity": "sha512-lvb1SBsI0Z7GDwmuid+mU3kWVBwTVUbe7S0H52yaaAdQOXq2YktTCZdlAcNKFzE6QtRz0snpw9bNiPeOIkkQvw==", + "license": "MIT", + "dependencies": { + "node-fetch": "2.6.7" + } + }, + "node_modules/cross-fetch/node_modules/node-fetch": { + "version": "2.6.7", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz", + "integrity": "sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==", + "license": "MIT", + "dependencies": { + "whatwg-url": "^5.0.0" + }, + "engines": { + "node": "4.x || >=6.0.0" + }, + "peerDependencies": { + "encoding": "^0.1.0" + }, + "peerDependenciesMeta": { + "encoding": { + "optional": true + } + } + }, + "node_modules/crypto-addr-codec": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/crypto-addr-codec/-/crypto-addr-codec-0.1.7.tgz", + "integrity": "sha512-X4hzfBzNhy4mAc3UpiXEC/L0jo5E8wAa9unsnA8nNXYzXjCcGk83hfC5avJWCSGT8V91xMnAS9AKMHmjw5+XCg==", + "license": "MIT", + "dependencies": { + "base-x": "^3.0.8", + "big-integer": "1.6.36", + "blakejs": "^1.1.0", + "bs58": "^4.0.1", + "ripemd160-min": "0.0.6", + "safe-buffer": "^5.2.0", + "sha3": "^2.1.1" + } + }, + "node_modules/crypto-hash": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/crypto-hash/-/crypto-hash-1.3.0.tgz", + "integrity": "sha512-lyAZ0EMyjDkVvz8WOeVnuCPvKVBXcMv1l5SVqO1yC7PzTwrD/pPje/BIRbWhMoPe436U+Y2nD7f5bFx0kt+Sbg==", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "license": "MIT", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/debug/node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "license": "MIT" + }, + "node_modules/decamelize": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz", + "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/decimal.js": { + "version": "10.4.3", + "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.4.3.tgz", + "integrity": "sha512-VBBaLc1MgL5XpzgIP7ny5Z6Nx3UrRkIViUkPUdtl9aya5amy3De1gsUUSB1g3+3sExYNjCAsAznmukyxCb1GRA==", + "license": "MIT" + }, + "node_modules/deep-eql": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.3.tgz", + "integrity": "sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==", + "license": "MIT", + "dependencies": { + "type-detect": "^4.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/define-properties": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz", + "integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==", + "license": "MIT", + "dependencies": { + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/delay": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/delay/-/delay-5.0.0.tgz", + "integrity": "sha512-ReEBKkIfe4ya47wlPYf/gu5ib6yUG0/Aez0JQZQz94kiWtRQvZIQbTiehsnwHvLSWJnQdhVeqYue7Id1dKr0qw==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/diff": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz", + "integrity": "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/dot-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/dot-case/-/dot-case-3.0.4.tgz", + "integrity": "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==", + "license": "MIT", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/drbg.js": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/drbg.js/-/drbg.js-1.0.1.tgz", + "integrity": "sha512-F4wZ06PvqxYLFEZKkFxTDcns9oFNk34hvmJSEwdzsxVQ8YI5YaxtACgQatkYgv2VI2CFkUd2Y+xosPQnHv809g==", + "license": "MIT", + "optional": true, + "dependencies": { + "browserify-aes": "^1.0.6", + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/eccrypto": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/eccrypto/-/eccrypto-1.1.6.tgz", + "integrity": "sha512-d78ivVEzu7Tn0ZphUUaL43+jVPKTMPFGtmgtz1D0LrFn7cY3K8CdrvibuLz2AAkHBLKZtR8DMbB2ukRYFk987A==", + "hasInstallScript": true, + "license": "CC0-1.0", + "dependencies": { + "acorn": "7.1.1", + "elliptic": "6.5.4", + "es6-promise": "4.2.8", + "nan": "2.14.0" + }, + "optionalDependencies": { + "secp256k1": "3.7.1" + } + }, + "node_modules/eccrypto/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "license": "MIT", + "optional": true + }, + "node_modules/eccrypto/node_modules/nan": { + "version": "2.14.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.0.tgz", + "integrity": "sha512-INOFj37C7k3AfaNTtX8RhsTw7qRy7eLET14cROi9+5HAVbbHuIWUHEauBv5qT4Av2tWasiTY1Jw6puUNqRJXQg==", + "license": "MIT" + }, + "node_modules/eccrypto/node_modules/secp256k1": { + "version": "3.7.1", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-3.7.1.tgz", + "integrity": "sha512-1cf8sbnRreXrQFdH6qsg2H71Xw91fCCS9Yp021GnUNJzWJS/py96fS4lHbnTnouLp08Xj6jBoBB6V78Tdbdu5g==", + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "dependencies": { + "bindings": "^1.5.0", + "bip66": "^1.1.5", + "bn.js": "^4.11.8", + "create-hash": "^1.2.0", + "drbg.js": "^1.0.1", + "elliptic": "^6.4.1", + "nan": "^2.14.0", + "safe-buffer": "^5.1.2" + }, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/eccrypto/node_modules/secp256k1/node_modules/nan": { + "version": "2.17.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.17.0.tgz", + "integrity": "sha512-2ZTgtl0nJsO0KQCjEpxcIr5D+Yv90plTitZt9JBfQvVJDS5seMl3FOvsh3+9CoYWXf/1l5OaZzzF6nDm4cagaQ==", + "license": "MIT", + "optional": true + }, + "node_modules/elliptic": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz", + "integrity": "sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==", + "license": "MIT", + "dependencies": { + "bn.js": "^4.11.9", + "brorand": "^1.1.0", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.1", + "inherits": "^2.0.4", + "minimalistic-assert": "^1.0.1", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "node_modules/elliptic/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "license": "MIT" + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" + }, + "node_modules/error-polyfill": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/error-polyfill/-/error-polyfill-0.1.3.tgz", + "integrity": "sha512-XHJk60ufE+TG/ydwp4lilOog549iiQF2OAPhkk9DdiYWMrltz5yhDz/xnKuenNwP7gy3dsibssO5QpVhkrSzzg==", + "license": "MIT", + "dependencies": { + "capability": "^0.2.5", + "o3": "^1.0.3", + "u3": "^0.1.1" + } + }, + "node_modules/es6-promise": { + "version": "4.2.8", + "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.8.tgz", + "integrity": "sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==", + "license": "MIT" + }, + "node_modules/es6-promisify": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz", + "integrity": "sha512-C+d6UdsYDk0lMebHNR4S2NybQMMngAOnOwYBQjTOiv0MkoJMP0Myw2mgpDLBcpfCmRLxyFqYhS/CfOENq4SJhQ==", + "license": "MIT", + "dependencies": { + "es6-promise": "^4.0.3" + } + }, + "node_modules/escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eth-crypto": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/eth-crypto/-/eth-crypto-2.6.0.tgz", + "integrity": "sha512-GCX4ffFYRUGgnuWR5qxcZIRQJ1KEqPFiyXU9yVy7s6dtXIMlUXZQ2h+5ID6rFaOHWbpJbjfkC6YdhwtwRYCnug==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "7.20.13", + "@ethereumjs/tx": "3.5.2", + "@types/bn.js": "5.1.1", + "eccrypto": "1.1.6", + "ethereumjs-util": "7.1.5", + "ethers": "5.7.2", + "secp256k1": "5.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/pubkey" + } + }, + "node_modules/eth-crypto/node_modules/@babel/runtime": { + "version": "7.20.13", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.20.13.tgz", + "integrity": "sha512-gt3PKXs0DBoL9xCvOIIZ2NEqAGZqHjAnmVbfQtB620V0uReIQutpel14KcneZuer7UioY8ALKZ7iocavvzTNFA==", + "license": "MIT", + "dependencies": { + "regenerator-runtime": "^0.13.11" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/eth-crypto/node_modules/node-addon-api": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-5.1.0.tgz", + "integrity": "sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA==", + "license": "MIT" + }, + "node_modules/eth-crypto/node_modules/secp256k1": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-5.0.0.tgz", + "integrity": "sha512-TKWX8xvoGHrxVdqbYeZM9w+izTF4b9z3NhSaDkdn81btvuh+ivbIMGT/zQvDtTFWhRlThpoz6LEYTr7n8A5GcA==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "elliptic": "^6.5.4", + "node-addon-api": "^5.0.0", + "node-gyp-build": "^4.2.0" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "license": "MIT", + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/ethereumjs-abi": { + "version": "0.6.8", + "resolved": "https://registry.npmjs.org/ethereumjs-abi/-/ethereumjs-abi-0.6.8.tgz", + "integrity": "sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA==", + "license": "MIT", + "dependencies": { + "bn.js": "^4.11.8", + "ethereumjs-util": "^6.0.0" + } + }, + "node_modules/ethereumjs-abi/node_modules/@types/bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/ethereumjs-abi/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "license": "MIT" + }, + "node_modules/ethereumjs-abi/node_modules/ethereumjs-util": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-6.2.1.tgz", + "integrity": "sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw==", + "license": "MPL-2.0", + "dependencies": { + "@types/bn.js": "^4.11.3", + "bn.js": "^4.11.0", + "create-hash": "^1.1.2", + "elliptic": "^6.5.2", + "ethereum-cryptography": "^0.1.3", + "ethjs-util": "0.1.6", + "rlp": "^2.2.3" + } + }, + "node_modules/ethereumjs-util": { + "version": "7.1.5", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz", + "integrity": "sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==", + "license": "MPL-2.0", + "dependencies": { + "@types/bn.js": "^5.1.0", + "bn.js": "^5.1.2", + "create-hash": "^1.1.2", + "ethereum-cryptography": "^0.1.3", + "rlp": "^2.2.4" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/ethers": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-5.7.2.tgz", + "integrity": "sha512-wswUsmWo1aOK8rR7DIKiWSw9DbLWe6x98Jrn8wcTflTVvaXhAMaB5zGAXy0GYQEQp9iO1iSHWVyARQm11zUtyg==", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abi": "5.7.0", + "@ethersproject/abstract-provider": "5.7.0", + "@ethersproject/abstract-signer": "5.7.0", + "@ethersproject/address": "5.7.0", + "@ethersproject/base64": "5.7.0", + "@ethersproject/basex": "5.7.0", + "@ethersproject/bignumber": "5.7.0", + "@ethersproject/bytes": "5.7.0", + "@ethersproject/constants": "5.7.0", + "@ethersproject/contracts": "5.7.0", + "@ethersproject/hash": "5.7.0", + "@ethersproject/hdnode": "5.7.0", + "@ethersproject/json-wallets": "5.7.0", + "@ethersproject/keccak256": "5.7.0", + "@ethersproject/logger": "5.7.0", + "@ethersproject/networks": "5.7.1", + "@ethersproject/pbkdf2": "5.7.0", + "@ethersproject/properties": "5.7.0", + "@ethersproject/providers": "5.7.2", + "@ethersproject/random": "5.7.0", + "@ethersproject/rlp": "5.7.0", + "@ethersproject/sha2": "5.7.0", + "@ethersproject/signing-key": "5.7.0", + "@ethersproject/solidity": "5.7.0", + "@ethersproject/strings": "5.7.0", + "@ethersproject/transactions": "5.7.0", + "@ethersproject/units": "5.7.0", + "@ethersproject/wallet": "5.7.0", + "@ethersproject/web": "5.7.1", + "@ethersproject/wordlists": "5.7.0" + } + }, + "node_modules/ethjs-util": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/ethjs-util/-/ethjs-util-0.1.6.tgz", + "integrity": "sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w==", + "license": "MIT", + "dependencies": { + "is-hex-prefixed": "1.0.0", + "strip-hex-prefix": "1.0.0" + }, + "engines": { + "node": ">=6.5.0", + "npm": ">=3" + } + }, + "node_modules/eventemitter3": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz", + "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==", + "license": "MIT" + }, + "node_modules/evp_bytestokey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", + "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", + "license": "MIT", + "dependencies": { + "md5.js": "^1.3.4", + "safe-buffer": "^5.1.1" + } + }, + "node_modules/eyes": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/eyes/-/eyes-0.1.8.tgz", + "integrity": "sha512-GipyPsXO1anza0AOZdy69Im7hGFCNB7Y/NGjDlZGJ3GJJLtwNSb2vrzYrTYJRrRloVx7pl+bhUaTB8yiccPvFQ==", + "engines": { + "node": "> 0.1.90" + } + }, + "node_modules/fast-stable-stringify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fast-stable-stringify/-/fast-stable-stringify-1.0.0.tgz", + "integrity": "sha512-wpYMUmFu5f00Sm0cj2pfivpmawLZ0NKdviQ4w9zJeR8JVtOpOxHmLaJuj0vxvGqMJQWyP/COUkF75/57OKyRag==", + "license": "MIT" + }, + "node_modules/file-uri-to-path": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz", + "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==", + "license": "MIT" + }, + "node_modules/fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", + "license": "BSD-3-Clause", + "bin": { + "flat": "cli.js" + } + }, + "node_modules/follow-redirects": { + "version": "1.15.2", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz", + "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "license": "MIT", + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/form-data": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz", + "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==", + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "license": "ISC" + }, + "node_modules/function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "license": "MIT" + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "license": "ISC", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-func-name": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz", + "integrity": "sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/globalthis": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", + "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", + "license": "MIT", + "dependencies": { + "define-properties": "^1.1.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/google-protobuf": { + "version": "3.21.2", + "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.21.2.tgz", + "integrity": "sha512-3MSOYFO5U9mPGikIYCzK0SaThypfGgS6bHqrUGXG3DPHCrb+txNqeEcns1W0lkGfk0rCyNXm7xB9rMxnCiZOoA==", + "license": "(BSD-3-Clause AND Apache-2.0)" + }, + "node_modules/graphql": { + "version": "16.6.0", + "resolved": "https://registry.npmjs.org/graphql/-/graphql-16.6.0.tgz", + "integrity": "sha512-KPIBPDlW7NxrbT/eh4qPXz5FiFdL5UbaA0XUNz2Rp3Z3hqBSkbj0GVjwFDztsWVauZUWsbKHgMg++sk8UX0bkw==", + "license": "MIT", + "engines": { + "node": "^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0" + } + }, + "node_modules/graphql-tag": { + "version": "2.12.6", + "resolved": "https://registry.npmjs.org/graphql-tag/-/graphql-tag-2.12.6.tgz", + "integrity": "sha512-FdSNcu2QQcWnM2VNvSCCDCVS5PpPqpzgFT8+GXzqJuoDd0CBncxCY278u4mhRO7tMgo2JjgJA5aZ+nWSQ/Z+xg==", + "license": "MIT", + "dependencies": { + "tslib": "^2.1.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "graphql": "^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0" + } + }, + "node_modules/has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.1" + }, + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/has-property-descriptors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", + "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "license": "MIT", + "dependencies": { + "get-intrinsic": "^1.1.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hash-base": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.1.0.tgz", + "integrity": "sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.4", + "readable-stream": "^3.6.0", + "safe-buffer": "^5.2.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/hash.js": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz", + "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.1" + } + }, + "node_modules/he": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", + "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", + "license": "MIT", + "bin": { + "he": "bin/he" + } + }, + "node_modules/hi-base32": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/hi-base32/-/hi-base32-0.5.1.tgz", + "integrity": "sha512-EmBBpvdYh/4XxsnUybsPag6VikPYnN30td+vQk+GI3qpahVEG9+gTkG0aXVxTjBqQ5T6ijbWIu77O+C5WFWsnA==", + "license": "MIT" + }, + "node_modules/hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==", + "license": "MIT", + "dependencies": { + "hash.js": "^1.0.3", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "node_modules/hoist-non-react-statics": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz", + "integrity": "sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==", + "license": "BSD-3-Clause", + "dependencies": { + "react-is": "^16.7.0" + } + }, + "node_modules/http-errors": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.8.1.tgz", + "integrity": "sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g==", + "license": "MIT", + "dependencies": { + "depd": "~1.1.2", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": ">= 1.5.0 < 2", + "toidentifier": "1.0.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/http-errors/node_modules/depd": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz", + "integrity": "sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/http-status-codes": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/http-status-codes/-/http-status-codes-2.2.0.tgz", + "integrity": "sha512-feERVo9iWxvnejp3SEfm/+oNG517npqL2/PIA8ORjyOZjGC7TwCRQsZylciLS64i6pJ0wRYz3rkXLRwbtFa8Ng==", + "license": "MIT" + }, + "node_modules/humanize-ms": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz", + "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==", + "license": "MIT", + "dependencies": { + "ms": "^2.0.0" + } + }, + "node_modules/ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "license": "ISC", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/interpret": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz", + "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "license": "MIT", + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-core-module": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.11.0.tgz", + "integrity": "sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==", + "license": "MIT", + "dependencies": { + "has": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-hex-prefixed": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-hex-prefixed/-/is-hex-prefixed-1.0.0.tgz", + "integrity": "sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA==", + "license": "MIT", + "engines": { + "node": ">=6.5.0", + "npm": ">=3" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-unicode-supported": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz", + "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==", + "license": "MIT" + }, + "node_modules/isomorphic-ws": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/isomorphic-ws/-/isomorphic-ws-4.0.1.tgz", + "integrity": "sha512-BhBvN2MBpWTaSHdWRb/bwdZJ1WaehQ2L1KngkCkfLUGF0mAWAT1sQUQacEmQ0jXkFw/czDXPNQSL5u2/Krsz1w==", + "license": "MIT", + "peerDependencies": { + "ws": "*" + } + }, + "node_modules/jayson": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jayson/-/jayson-4.0.0.tgz", + "integrity": "sha512-v2RNpDCMu45fnLzSk47vx7I+QUaOsox6f5X0CUlabAFwxoP+8MfAY0NQRFwOEYXIxm8Ih5y6OaEa5KYiQMkyAA==", + "license": "MIT", + "dependencies": { + "@types/connect": "^3.4.33", + "@types/node": "^12.12.54", + "@types/ws": "^7.4.4", + "commander": "^2.20.3", + "delay": "^5.0.0", + "es6-promisify": "^5.0.0", + "eyes": "^0.1.8", + "isomorphic-ws": "^4.0.1", + "json-stringify-safe": "^5.0.1", + "JSONStream": "^1.3.5", + "uuid": "^8.3.2", + "ws": "^7.4.5" + }, + "bin": { + "jayson": "bin/jayson.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jayson/node_modules/@types/node": { + "version": "12.20.55", + "resolved": "https://registry.npmjs.org/@types/node/-/node-12.20.55.tgz", + "integrity": "sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==", + "license": "MIT" + }, + "node_modules/js-base64": { + "version": "3.7.5", + "resolved": "https://registry.npmjs.org/js-base64/-/js-base64-3.7.5.tgz", + "integrity": "sha512-3MEt5DTINKqfScXKfJFrRbxkrnk2AxPWGBL/ycjz4dK8iqiSJ06UxD8jh8xuh6p10TX4t2+7FsBYVxxQbMg+qA==", + "license": "BSD-3-Clause" + }, + "node_modules/js-sha256": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/js-sha256/-/js-sha256-0.9.0.tgz", + "integrity": "sha512-sga3MHh9sgQN2+pJ9VYZ+1LPwXOxuBJBA5nrR5/ofPfuiJBE2hnjsaN8se8JznOmGLN2p49Pe5U/ttafcs/apA==", + "license": "MIT" + }, + "node_modules/js-sha3": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz", + "integrity": "sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==", + "license": "MIT" + }, + "node_modules/js-sha512": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/js-sha512/-/js-sha512-0.8.0.tgz", + "integrity": "sha512-PWsmefG6Jkodqt+ePTvBZCSMFgN7Clckjd0O7su3I0+BW2QWUTJNzjktHsztGLhncP2h8mcF9V9Y2Ha59pAViQ==", + "license": "MIT" + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jscrypto": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/jscrypto/-/jscrypto-1.0.3.tgz", + "integrity": "sha512-lryZl0flhodv4SZHOqyb1bx5sKcJxj0VBo0Kzb4QMAg3L021IC9uGpl0RCZa+9KJwlRGSK2C80ITcwbe19OKLQ==", + "license": "MIT", + "bin": { + "jscrypto": "bin/cli.js" + } + }, + "node_modules/json-bigint": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz", + "integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==", + "license": "MIT", + "dependencies": { + "bignumber.js": "^9.0.0" + } + }, + "node_modules/json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==", + "license": "ISC" + }, + "node_modules/json5": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz", + "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==", + "license": "MIT", + "optional": true, + "dependencies": { + "minimist": "^1.2.0" + }, + "bin": { + "json5": "lib/cli.js" + } + }, + "node_modules/jsonparse": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", + "integrity": "sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==", + "engines": [ + "node >= 0.2.0" + ], + "license": "MIT" + }, + "node_modules/jsonschema": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/jsonschema/-/jsonschema-1.4.1.tgz", + "integrity": "sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/JSONStream": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz", + "integrity": "sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==", + "license": "(MIT OR Apache-2.0)", + "dependencies": { + "jsonparse": "^1.2.0", + "through": ">=2.2.7 <3" + }, + "bin": { + "JSONStream": "bin.js" + }, + "engines": { + "node": "*" + } + }, + "node_modules/keccak": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/keccak/-/keccak-3.0.3.tgz", + "integrity": "sha512-JZrLIAJWuZxKbCilMpNz5Vj7Vtb4scDG3dMXLOsbzBmQGyjwE61BbW7bJkfKKCShXiQZt3T6sBgALRtmd+nZaQ==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "node-addon-api": "^2.0.0", + "node-gyp-build": "^4.2.0", + "readable-stream": "^3.6.0" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/keccak256": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/keccak256/-/keccak256-1.0.6.tgz", + "integrity": "sha512-8GLiM01PkdJVGUhR1e6M/AvWnSqYS0HaERI+K/QtStGDGlSTx2B1zTqZk4Zlqu5TxHJNTxWAdP9Y+WI50OApUw==", + "license": "MIT", + "dependencies": { + "bn.js": "^5.2.0", + "buffer": "^6.0.3", + "keccak": "^3.0.2" + } + }, + "node_modules/libsodium": { + "version": "0.7.11", + "resolved": "https://registry.npmjs.org/libsodium/-/libsodium-0.7.11.tgz", + "integrity": "sha512-WPfJ7sS53I2s4iM58QxY3Inb83/6mjlYgcmZs7DJsvDlnmVUwNinBCi5vBT43P6bHRy01O4zsMU2CoVR6xJ40A==", + "license": "ISC" + }, + "node_modules/libsodium-wrappers": { + "version": "0.7.11", + "resolved": "https://registry.npmjs.org/libsodium-wrappers/-/libsodium-wrappers-0.7.11.tgz", + "integrity": "sha512-SrcLtXj7BM19vUKtQuyQKiQCRJPgbpauzl3s0rSwD+60wtHqSUuqcoawlMDheCJga85nKOQwxNYQxf/CKAvs6Q==", + "license": "ISC", + "dependencies": { + "libsodium": "^0.7.11" + } + }, + "node_modules/link-module-alias": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/link-module-alias/-/link-module-alias-1.2.0.tgz", + "integrity": "sha512-ahPjXepbSVKbahTB6LxR//VHm8HPfI+QQygCH+E82spBY4HR5VPJTvlhKBc9F7muVxnS6C1rRfoPOXAbWO/fyw==", + "license": "MIT", + "dependencies": { + "chalk": "^2.4.1" + }, + "bin": { + "link-module-alias": "index.js" + }, + "engines": { + "node": "> 8.0.0" + } + }, + "node_modules/link-module-alias/node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "license": "MIT", + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/link-module-alias/node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/link-module-alias/node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "license": "MIT", + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/link-module-alias/node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "license": "MIT" + }, + "node_modules/link-module-alias/node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "license": "MIT", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/link-module-alias/node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/link-module-alias/node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "license": "MIT", + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", + "license": "MIT" + }, + "node_modules/lodash.values": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/lodash.values/-/lodash.values-4.3.0.tgz", + "integrity": "sha512-r0RwvdCv8id9TUblb/O7rYPwVy6lerCbcawrfdo9iC/1t1wsNMJknO79WNBgwkH0hIeJ08jmvvESbFpNb4jH0Q==", + "license": "MIT" + }, + "node_modules/log-symbols": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", + "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==", + "license": "MIT", + "dependencies": { + "chalk": "^4.1.0", + "is-unicode-supported": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/long": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/long/-/long-4.0.0.tgz", + "integrity": "sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==", + "license": "Apache-2.0" + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "license": "MIT", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/loupe": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.6.tgz", + "integrity": "sha512-RaPMZKiMy8/JruncMU5Bt6na1eftNoo++R4Y+N2FrxkDVTrGvcyzFTsaGif4QTeKESheMGegbhw6iUAq+5A8zA==", + "license": "MIT", + "dependencies": { + "get-func-name": "^2.0.0" + } + }, + "node_modules/lower-case": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/lower-case/-/lower-case-2.0.2.tgz", + "integrity": "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==", + "license": "MIT", + "dependencies": { + "tslib": "^2.0.3" + } + }, + "node_modules/make-error": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", + "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==", + "license": "ISC" + }, + "node_modules/map-obj": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-4.3.0.tgz", + "integrity": "sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/md5.js": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz", + "integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==", + "license": "MIT", + "dependencies": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/minimalistic-assert": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", + "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==", + "license": "ISC" + }, + "node_modules/minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==", + "license": "MIT" + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/mkdirp": { + "version": "0.5.6", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz", + "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==", + "dependencies": { + "minimist": "^1.2.6" + }, + "bin": { + "mkdirp": "bin/cmd.js" + } + }, + "node_modules/mocha": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.2.0.tgz", + "integrity": "sha512-IDY7fl/BecMwFHzoqF2sg/SHHANeBoMMXFlS9r0OXKDssYE1M5O43wUY/9BVPeIvfH2zmEbBfseqN9gBQZzXkg==", + "license": "MIT", + "dependencies": { + "ansi-colors": "4.1.1", + "browser-stdout": "1.3.1", + "chokidar": "3.5.3", + "debug": "4.3.4", + "diff": "5.0.0", + "escape-string-regexp": "4.0.0", + "find-up": "5.0.0", + "glob": "7.2.0", + "he": "1.2.0", + "js-yaml": "4.1.0", + "log-symbols": "4.1.0", + "minimatch": "5.0.1", + "ms": "2.1.3", + "nanoid": "3.3.3", + "serialize-javascript": "6.0.0", + "strip-json-comments": "3.1.1", + "supports-color": "8.1.1", + "workerpool": "6.2.1", + "yargs": "16.2.0", + "yargs-parser": "20.2.4", + "yargs-unparser": "2.0.0" + }, + "bin": { + "_mocha": "bin/_mocha", + "mocha": "bin/mocha.js" + }, + "engines": { + "node": ">= 14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mochajs" + } + }, + "node_modules/mocha/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/mocha/node_modules/glob": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz", + "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==", + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/mocha/node_modules/glob/node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/mocha/node_modules/glob/node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/mocha/node_modules/minimatch": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz", + "integrity": "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==", + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/mustache": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/mustache/-/mustache-4.2.0.tgz", + "integrity": "sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==", + "license": "MIT", + "bin": { + "mustache": "bin/mustache" + } + }, + "node_modules/nan": { + "version": "2.17.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.17.0.tgz", + "integrity": "sha512-2ZTgtl0nJsO0KQCjEpxcIr5D+Yv90plTitZt9JBfQvVJDS5seMl3FOvsh3+9CoYWXf/1l5OaZzzF6nDm4cagaQ==", + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.3.tgz", + "integrity": "sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w==", + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/near-api-js": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/near-api-js/-/near-api-js-1.1.0.tgz", + "integrity": "sha512-qYKv1mYsaDZc2uYndhS+ttDhR9+60qFc+ZjD6lWsAxr3ZskMjRwPffDGQZYhC7BRDQMe1HEbk6d5mf+TVm0Lqg==", + "license": "(MIT AND Apache-2.0)", + "dependencies": { + "bn.js": "5.2.1", + "borsh": "^0.7.0", + "bs58": "^4.0.0", + "depd": "^2.0.0", + "error-polyfill": "^0.1.3", + "http-errors": "^1.7.2", + "js-sha256": "^0.9.0", + "mustache": "^4.0.0", + "node-fetch": "^2.6.1", + "text-encoding-utf-8": "^1.0.2", + "tweetnacl": "^1.0.1" + } + }, + "node_modules/no-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz", + "integrity": "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==", + "license": "MIT", + "dependencies": { + "lower-case": "^2.0.2", + "tslib": "^2.0.3" + } + }, + "node_modules/node-addon-api": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-2.0.2.tgz", + "integrity": "sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==", + "license": "MIT" + }, + "node_modules/node-fetch": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.9.tgz", + "integrity": "sha512-DJm/CJkZkRjKKj4Zi4BsKVZh3ValV5IR5s7LVZnW+6YMh0W1BfNA8XSs6DLMGYlId5F3KnA70uu2qepcR08Qqg==", + "license": "MIT", + "dependencies": { + "whatwg-url": "^5.0.0" + }, + "engines": { + "node": "4.x || >=6.0.0" + }, + "peerDependencies": { + "encoding": "^0.1.0" + }, + "peerDependenciesMeta": { + "encoding": { + "optional": true + } + } + }, + "node_modules/node-gyp-build": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.6.0.tgz", + "integrity": "sha512-NTZVKn9IylLwUzaKjkas1e4u2DLNcV4rdYagA4PWdPwW87Bi7z+BznyKSRwS/761tV/lzCGXplWsiaMjLqP2zQ==", + "license": "MIT", + "bin": { + "node-gyp-build": "bin.js", + "node-gyp-build-optional": "optional.js", + "node-gyp-build-test": "build-test.js" + } + }, + "node_modules/noms": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/noms/-/noms-0.0.0.tgz", + "integrity": "sha512-lNDU9VJaOPxUmXcLb+HQFeUgQQPtMI24Gt6hgfuMHRJgMRHMF/qZ4HJD3GDru4sSw9IQl2jPjAYnQrdIeLbwow==", + "license": "ISC", + "dependencies": { + "inherits": "^2.0.1", + "readable-stream": "~1.0.31" + } + }, + "node_modules/noms/node_modules/readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha512-ok1qVCJuRkNmvebYikljxJA/UEsKwLl2nI1OmaqAu4/UE+h0wKCHok4XkL/gvi39OacXvw59RJUOFUkDib2rHg==", + "license": "MIT", + "dependencies": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.1", + "isarray": "0.0.1", + "string_decoder": "~0.10.x" + } + }, + "node_modules/noms/node_modules/string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==", + "license": "MIT" + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/o3": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/o3/-/o3-1.0.3.tgz", + "integrity": "sha512-f+4n+vC6s4ysy7YO7O2gslWZBUu8Qj2i2OUJOvjRxQva7jVjYjB29jrr9NCjmxZQR0gzrOcv1RnqoYOeMs5VRQ==", + "license": "MIT", + "dependencies": { + "capability": "^0.2.5" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/optimism": { + "version": "0.16.2", + "resolved": "https://registry.npmjs.org/optimism/-/optimism-0.16.2.tgz", + "integrity": "sha512-zWNbgWj+3vLEjZNIh/okkY2EUfX+vB9TJopzIZwT1xxaMqC5hRLLraePod4c5n4He08xuXNH+zhKFFCu390wiQ==", + "license": "MIT", + "dependencies": { + "@wry/context": "^0.7.0", + "@wry/trie": "^0.3.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pako": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/pako/-/pako-2.1.0.tgz", + "integrity": "sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug==", + "license": "(MIT AND Zlib)" + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "license": "MIT" + }, + "node_modules/pathval": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz", + "integrity": "sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/pbkdf2": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.2.tgz", + "integrity": "sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==", + "license": "MIT", + "dependencies": { + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4", + "ripemd160": "^2.0.1", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + }, + "engines": { + "node": ">=0.12" + } + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/prettier": { + "version": "2.8.7", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.7.tgz", + "integrity": "sha512-yPngTo3aXUUmyuTjeTUT75txrf+aMh9FiD7q9ZE/i6r0bPb22g4FsE6Y338PQX1bmfy08i9QQCB7/rcUAVntfw==", + "license": "MIT", + "bin": { + "prettier": "bin-prettier.js" + }, + "engines": { + "node": ">=10.13.0" + }, + "funding": { + "url": "https://github.com/prettier/prettier?sponsor=1" + } + }, + "node_modules/process-nextick-args": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", + "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", + "license": "MIT" + }, + "node_modules/prop-types": { + "version": "15.8.1", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz", + "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + } + }, + "node_modules/protobufjs": { + "version": "6.11.3", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-6.11.3.tgz", + "integrity": "sha512-xL96WDdCZYdU7Slin569tFX712BxsxslWwAfAhCYjQKGTq7dAU91Lomy6nLLhh/dyGhk/YH4TwTSRxTzhuHyZg==", + "hasInstallScript": true, + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/long": "^4.0.1", + "@types/node": ">=13.7.0", + "long": "^4.0.0" + }, + "bin": { + "pbjs": "bin/pbjs", + "pbts": "bin/pbts" + } + }, + "node_modules/randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "license": "MIT", + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, + "node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==", + "license": "MIT" + }, + "node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "license": "MIT", + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/readonly-date": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/readonly-date/-/readonly-date-1.0.0.tgz", + "integrity": "sha512-tMKIV7hlk0h4mO3JTmmVuIlJVXjKk3Sep9Bf5OH0O+758ruuVkUy2J9SttDLm91IEX/WHlXPSpxMGjPj4beMIQ==", + "license": "Apache-2.0" + }, + "node_modules/rechoir": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz", + "integrity": "sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==", + "dependencies": { + "resolve": "^1.1.6" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/regenerator-runtime": { + "version": "0.13.11", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz", + "integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==", + "license": "MIT" + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve": { + "version": "1.22.2", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.2.tgz", + "integrity": "sha512-Sb+mjNHOULsBv818T40qSPeRiuWLyaGMa5ewydRLFimneixmVy2zdivRl+AF6jaYPC8ERxGDmFSiqui6SfPd+g==", + "license": "MIT", + "dependencies": { + "is-core-module": "^2.11.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/response-iterator": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/response-iterator/-/response-iterator-0.2.6.tgz", + "integrity": "sha512-pVzEEzrsg23Sh053rmDUvLSkGXluZio0qu8VT6ukrYuvtjVfCbDZH9d6PGXb8HZfzdNZt8feXv/jvUzlhRgLnw==", + "license": "MIT", + "engines": { + "node": ">=0.8" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "license": "ISC", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/ripemd160": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", + "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", + "license": "MIT", + "dependencies": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1" + } + }, + "node_modules/ripemd160-min": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/ripemd160-min/-/ripemd160-min-0.0.6.tgz", + "integrity": "sha512-+GcJgQivhs6S9qvLogusiTcS9kQUfgR75whKuy5jIhuiOfQuJ8fjqxV6EGD5duH1Y/FawFUMtMhyeq3Fbnib8A==", + "engines": { + "node": ">=8" + } + }, + "node_modules/rlp": { + "version": "2.2.7", + "resolved": "https://registry.npmjs.org/rlp/-/rlp-2.2.7.tgz", + "integrity": "sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ==", + "license": "MPL-2.0", + "dependencies": { + "bn.js": "^5.2.0" + }, + "bin": { + "rlp": "bin/rlp" + } + }, + "node_modules/rpc-websockets": { + "version": "7.5.1", + "resolved": "https://registry.npmjs.org/rpc-websockets/-/rpc-websockets-7.5.1.tgz", + "integrity": "sha512-kGFkeTsmd37pHPMaHIgN1LVKXMi0JD782v4Ds9ZKtLlwdTKjn+CxM9A9/gLT2LaOuEcEFGL98h1QWQtlOIdW0w==", + "license": "LGPL-3.0-only", + "dependencies": { + "@babel/runtime": "^7.17.2", + "eventemitter3": "^4.0.7", + "uuid": "^8.3.2", + "ws": "^8.5.0" + }, + "funding": { + "type": "paypal", + "url": "https://paypal.me/kozjak" + }, + "optionalDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + } + }, + "node_modules/rpc-websockets/node_modules/ws": { + "version": "8.13.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.13.0.tgz", + "integrity": "sha512-x9vcZYTrFPC7aSIbj7sRCYo7L/Xb8Iy+pW0ng0wt2vCJv7M9HOMy0UoN3rr+IFC7hb7vXoqS+P9ktyLLLhO+LA==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/rxjs": { + "version": "7.8.0", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.0.tgz", + "integrity": "sha512-F2+gxDshqmIub1KdvZkaEfGDwLNpPvk9Fs6LD/MyQxNgMds/WH9OdDDXOmxUZpME+iSK3rQCctkL0DYyytUqMg==", + "license": "Apache-2.0", + "dependencies": { + "tslib": "^2.1.0" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/scrypt-js": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/scrypt-js/-/scrypt-js-3.0.1.tgz", + "integrity": "sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==", + "license": "MIT" + }, + "node_modules/secp256k1": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-4.0.3.tgz", + "integrity": "sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "elliptic": "^6.5.4", + "node-addon-api": "^2.0.0", + "node-gyp-build": "^4.2.0" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/serialize-javascript": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz", + "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==", + "license": "BSD-3-Clause", + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "node_modules/setimmediate": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz", + "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==", + "license": "MIT" + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "license": "ISC" + }, + "node_modules/sha.js": { + "version": "2.4.11", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", + "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", + "license": "(MIT AND BSD-3-Clause)", + "dependencies": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + }, + "bin": { + "sha.js": "bin.js" + } + }, + "node_modules/sha3": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/sha3/-/sha3-2.1.4.tgz", + "integrity": "sha512-S8cNxbyb0UGUM2VhRD4Poe5N58gJnJsLJ5vC7FYWGUmGhcsj4++WaIOBFVDxlG0W3To6xBuiRh+i0Qp2oNCOtg==", + "license": "MIT", + "dependencies": { + "buffer": "6.0.3" + } + }, + "node_modules/shelljs": { + "version": "0.8.5", + "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.8.5.tgz", + "integrity": "sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==", + "license": "BSD-3-Clause", + "dependencies": { + "glob": "^7.0.0", + "interpret": "^1.0.0", + "rechoir": "^0.6.2" + }, + "bin": { + "shjs": "bin/shjs" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/shx": { + "version": "0.3.4", + "resolved": "https://registry.npmjs.org/shx/-/shx-0.3.4.tgz", + "integrity": "sha512-N6A9MLVqjxZYcVn8hLmtneQWIJtp8IKzMP4eMnx+nqkvXoqinUPCbUFLp2UcWTEIUONhlk0ewxr/jaVGlc+J+g==", + "license": "MIT", + "dependencies": { + "minimist": "^1.2.3", + "shelljs": "^0.8.5" + }, + "bin": { + "shx": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/snake-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/snake-case/-/snake-case-3.0.4.tgz", + "integrity": "sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==", + "license": "MIT", + "dependencies": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/snakecase-keys": { + "version": "5.4.5", + "resolved": "https://registry.npmjs.org/snakecase-keys/-/snakecase-keys-5.4.5.tgz", + "integrity": "sha512-qSQVcgcWk8mQUN1miVGnRMAUye1dbj9+F9PVkR7wZUXNCidQwrl/kOKmoYf+WbH2ju6c9pXnlmbS2he7pb2/9A==", + "license": "MIT", + "dependencies": { + "map-obj": "^4.1.0", + "snake-case": "^3.0.4", + "type-fest": "^2.5.2" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/statuses": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz", + "integrity": "sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/store2": { + "version": "2.14.2", + "resolved": "https://registry.npmjs.org/store2/-/store2-2.14.2.tgz", + "integrity": "sha512-siT1RiqlfQnGqgT/YzXVUNsom9S0H1OX+dpdGN1xkyYATo4I6sep5NmsRD/40s3IIOvlCq6akxkqG82urIZW1w==", + "license": "(MIT OR GPL-3.0)" + }, + "node_modules/string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/strip-hex-prefix": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-hex-prefix/-/strip-hex-prefix-1.0.0.tgz", + "integrity": "sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A==", + "license": "MIT", + "dependencies": { + "is-hex-prefixed": "1.0.0" + }, + "engines": { + "node": ">=6.5.0", + "npm": ">=3" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/superstruct": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/superstruct/-/superstruct-1.0.3.tgz", + "integrity": "sha512-8iTn3oSS8nRGn+C2pgXSKPI3jmpm6FExNazNpjvqS6ZUJQCej3PUXEKM8NjHBOs54ExM+LPW/FBRhymrdcCiSg==", + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/symbol-observable": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/symbol-observable/-/symbol-observable-4.0.0.tgz", + "integrity": "sha512-b19dMThMV4HVFynSAM1++gBHAbk2Tc/osgLIBZMKsyqh34jb2e8Os7T6ZW/Bt3pJFdBTd2JwAnAAEQV7rSNvcQ==", + "license": "MIT", + "engines": { + "node": ">=0.10" + } + }, + "node_modules/text-encoding-utf-8": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/text-encoding-utf-8/-/text-encoding-utf-8-1.0.2.tgz", + "integrity": "sha512-8bw4MY9WjdsD2aMtO0OzOCY3pXGYNx2d2FfHRVUKkiCPDWjKuOlhLVASS+pD7VkLTVjW268LYJHwsnPFlBpbAg==" + }, + "node_modules/through": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", + "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==", + "license": "MIT" + }, + "node_modules/through2": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz", + "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==", + "license": "MIT", + "dependencies": { + "readable-stream": "~2.3.6", + "xtend": "~4.0.1" + } + }, + "node_modules/through2/node_modules/isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==", + "license": "MIT" + }, + "node_modules/through2/node_modules/readable-stream": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz", + "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==", + "license": "MIT", + "dependencies": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "node_modules/through2/node_modules/safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "license": "MIT" + }, + "node_modules/through2/node_modules/string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.1.0" + } + }, + "node_modules/tiny-secp256k1": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/tiny-secp256k1/-/tiny-secp256k1-1.1.6.tgz", + "integrity": "sha512-FmqJZGduTyvsr2cF3375fqGHUovSwDi/QytexX1Se4BPuPZpTE5Ftp5fg+EFSuEf3lhZqgCRjEG3ydUQ/aNiwA==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "bindings": "^1.3.0", + "bn.js": "^4.11.8", + "create-hmac": "^1.1.7", + "elliptic": "^6.4.0", + "nan": "^2.13.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/tiny-secp256k1/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "license": "MIT" + }, + "node_modules/tmp": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.1.tgz", + "integrity": "sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==", + "license": "MIT", + "dependencies": { + "rimraf": "^3.0.0" + }, + "engines": { + "node": ">=8.17.0" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/toml": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/toml/-/toml-3.0.0.tgz", + "integrity": "sha512-y/mWCZinnvxjTKYhJ+pYxwD0mRLVvOtdS2Awbgxln6iEnt4rk0yBxeSBHkGJcPucRiG0e55mwWp+g/05rsrd6w==", + "license": "MIT" + }, + "node_modules/tr46": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", + "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==", + "license": "MIT" + }, + "node_modules/ts-invariant": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/ts-invariant/-/ts-invariant-0.10.3.tgz", + "integrity": "sha512-uivwYcQaxAucv1CzRp2n/QdYPo4ILf9VXgH19zEIjFx2EJufV16P0JtJVpYHy89DItG6Kwj2oIUjrcK5au+4tQ==", + "license": "MIT", + "dependencies": { + "tslib": "^2.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ts-mocha": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/ts-mocha/-/ts-mocha-10.0.0.tgz", + "integrity": "sha512-VRfgDO+iiuJFlNB18tzOfypJ21xn2xbuZyDvJvqpTbWgkAgD17ONGr8t+Tl8rcBtOBdjXp5e/Rk+d39f7XBHRw==", + "license": "MIT", + "dependencies": { + "ts-node": "7.0.1" + }, + "bin": { + "ts-mocha": "bin/ts-mocha" + }, + "engines": { + "node": ">= 6.X.X" + }, + "optionalDependencies": { + "tsconfig-paths": "^3.5.0" + }, + "peerDependencies": { + "mocha": "^3.X.X || ^4.X.X || ^5.X.X || ^6.X.X || ^7.X.X || ^8.X.X || ^9.X.X || ^10.X.X" + } + }, + "node_modules/ts-mocha/node_modules/diff": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz", + "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==", + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/ts-mocha/node_modules/ts-node": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-7.0.1.tgz", + "integrity": "sha512-BVwVbPJRspzNh2yfslyT1PSbl5uIk03EZlb493RKHN4qej/D06n1cEhjlOJG69oFsE7OT8XjpTUcYf6pKTLMhw==", + "dependencies": { + "arrify": "^1.0.0", + "buffer-from": "^1.1.0", + "diff": "^3.1.0", + "make-error": "^1.1.1", + "minimist": "^1.2.0", + "mkdirp": "^0.5.1", + "source-map-support": "^0.5.6", + "yn": "^2.0.0" + }, + "bin": { + "ts-node": "dist/bin.js" + }, + "engines": { + "node": ">=4.2.0" + } + }, + "node_modules/ts-mocha/node_modules/yn": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/yn/-/yn-2.0.0.tgz", + "integrity": "sha512-uTv8J/wiWTgUTg+9vLTi//leUl5vDQS6uii/emeTb2ssY7vl6QWf2fFbIIGjnhjvbdKlU0ed7QPgY1htTC86jQ==", + "engines": { + "node": ">=4" + } + }, + "node_modules/ts-node": { + "version": "10.9.1", + "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz", + "integrity": "sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==", + "dependencies": { + "@cspotcode/source-map-support": "^0.8.0", + "@tsconfig/node10": "^1.0.7", + "@tsconfig/node12": "^1.0.7", + "@tsconfig/node14": "^1.0.0", + "@tsconfig/node16": "^1.0.2", + "acorn": "^8.4.1", + "acorn-walk": "^8.1.1", + "arg": "^4.1.0", + "create-require": "^1.1.0", + "diff": "^4.0.1", + "make-error": "^1.1.1", + "v8-compile-cache-lib": "^3.0.1", + "yn": "3.1.1" + }, + "bin": { + "ts-node": "dist/bin.js", + "ts-node-cwd": "dist/bin-cwd.js", + "ts-node-esm": "dist/bin-esm.js", + "ts-node-script": "dist/bin-script.js", + "ts-node-transpile-only": "dist/bin-transpile.js", + "ts-script": "dist/bin-script-deprecated.js" + }, + "peerDependencies": { + "@swc/core": ">=1.2.50", + "@swc/wasm": ">=1.2.50", + "@types/node": "*", + "typescript": ">=2.7" + }, + "peerDependenciesMeta": { + "@swc/core": { + "optional": true + }, + "@swc/wasm": { + "optional": true + } + } + }, + "node_modules/ts-node/node_modules/acorn": { + "version": "8.8.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz", + "integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/ts-node/node_modules/diff": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz", + "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==", + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/tsconfig-paths": { + "version": "3.14.2", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.2.tgz", + "integrity": "sha512-o/9iXgCYc5L/JxCHPe3Hvh8Q/2xm5Z+p18PESBU6Ff33695QnCHBEjcytY2q19ua7Mbl/DavtBOLq+oG0RCL+g==", + "license": "MIT", + "optional": true, + "dependencies": { + "@types/json5": "^0.0.29", + "json5": "^1.0.2", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + } + }, + "node_modules/tslib": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.5.0.tgz", + "integrity": "sha512-336iVw3rtn2BUK7ORdIAHTyxHGRIHVReokCR3XjbckJMK7ms8FysBfhLR8IXnAgy7T0PTPNBWKiH514FOW/WSg==", + "license": "0BSD" + }, + "node_modules/tweetnacl": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz", + "integrity": "sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==", + "license": "Unlicense" + }, + "node_modules/tweetnacl-util": { + "version": "0.15.1", + "resolved": "https://registry.npmjs.org/tweetnacl-util/-/tweetnacl-util-0.15.1.tgz", + "integrity": "sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw==", + "license": "Unlicense" + }, + "node_modules/type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/type-fest": { + "version": "2.19.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-2.19.0.tgz", + "integrity": "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==", + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=12.20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typeforce": { + "version": "1.18.0", + "resolved": "https://registry.npmjs.org/typeforce/-/typeforce-1.18.0.tgz", + "integrity": "sha512-7uc1O8h1M1g0rArakJdf0uLRSSgFcYexrVoKo+bzJd32gd4gDy2L/Z+8/FjPnU9ydY3pEnVPtr9FyscYY60K1g==", + "license": "MIT" + }, + "node_modules/typescript": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.4.tgz", + "integrity": "sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==", + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=12.20" + } + }, + "node_modules/u3": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/u3/-/u3-0.1.1.tgz", + "integrity": "sha512-+J5D5ir763y+Am/QY6hXNRlwljIeRMZMGs0cT6qqZVVzzT3X3nFPXVyPOFRMOR4kupB0T8JnCdpWdp6Q/iXn3w==", + "license": "MIT" + }, + "node_modules/untildify": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/untildify/-/untildify-4.0.0.tgz", + "integrity": "sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/utf-8-validate": { + "version": "5.0.10", + "resolved": "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-5.0.10.tgz", + "integrity": "sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "node-gyp-build": "^4.3.0" + }, + "engines": { + "node": ">=6.14.2" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "license": "MIT" + }, + "node_modules/uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "license": "MIT", + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/v8-compile-cache-lib": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz", + "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==" + }, + "node_modules/vlq": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/vlq/-/vlq-2.0.4.tgz", + "integrity": "sha512-aodjPa2wPQFkra1G8CzJBTHXhgk3EVSwxSWXNPr1fgdFLUb8kvLV1iEb6rFgasIsjP82HWI6dsb5Io26DDnasA==", + "license": "MIT" + }, + "node_modules/webidl-conversions": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", + "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==", + "license": "BSD-2-Clause" + }, + "node_modules/whatwg-url": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", + "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", + "license": "MIT", + "dependencies": { + "tr46": "~0.0.3", + "webidl-conversions": "^3.0.0" + } + }, + "node_modules/wif": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/wif/-/wif-2.0.6.tgz", + "integrity": "sha512-HIanZn1zmduSF+BQhkE+YXIbEiH0xPr1012QbFEGB0xsKqJii0/SqJjyn8dFv6y36kOznMgMB+LGcbZTJ1xACQ==", + "license": "MIT", + "dependencies": { + "bs58check": "<3.0.0" + } + }, + "node_modules/workerpool": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz", + "integrity": "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==", + "license": "Apache-2.0" + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "license": "ISC" + }, + "node_modules/ws": { + "version": "7.5.9", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz", + "integrity": "sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==", + "license": "MIT", + "engines": { + "node": ">=8.3.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/xstream": { + "version": "11.14.0", + "resolved": "https://registry.npmjs.org/xstream/-/xstream-11.14.0.tgz", + "integrity": "sha512-1bLb+kKKtKPbgTK6i/BaoAn03g47PpFstlbe1BA+y3pNS/LfvcaghS5BFf9+EE1J+KwSQsEpfJvFN5GqFtiNmw==", + "license": "MIT", + "dependencies": { + "globalthis": "^1.0.1", + "symbol-observable": "^2.0.3" + } + }, + "node_modules/xstream/node_modules/symbol-observable": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/symbol-observable/-/symbol-observable-2.0.3.tgz", + "integrity": "sha512-sQV7phh2WCYAn81oAkakC5qjq2Ml0g8ozqz03wOGnx9dDlG1de6yrF+0RAzSJD8fPUow3PTSMf2SAbOGxb93BA==", + "license": "MIT", + "engines": { + "node": ">=0.10" + } + }, + "node_modules/xtend": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", + "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", + "license": "MIT", + "engines": { + "node": ">=0.4" + } + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs": { + "version": "16.2.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", + "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", + "license": "MIT", + "dependencies": { + "cliui": "^7.0.2", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.0", + "y18n": "^5.0.5", + "yargs-parser": "^20.2.2" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-parser": { + "version": "20.2.4", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz", + "integrity": "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-unparser": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz", + "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==", + "license": "MIT", + "dependencies": { + "camelcase": "^6.0.0", + "decamelize": "^4.0.0", + "flat": "^5.0.2", + "is-plain-obj": "^2.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-unparser/node_modules/camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/yargs/node_modules/yargs-parser": { + "version": "20.2.9", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz", + "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yn": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz", + "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==", + "engines": { + "node": ">=6" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zen-observable": { + "version": "0.8.15", + "resolved": "https://registry.npmjs.org/zen-observable/-/zen-observable-0.8.15.tgz", + "integrity": "sha512-PQ2PC7R9rslx84ndNBZB/Dkv8V8fZEpk83RLgXtYd0fwUgEjseMn1Dgajh2x6S8QbZAFa9p2qVCEuYZNgve0dQ==", + "license": "MIT" + }, + "node_modules/zen-observable-ts": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/zen-observable-ts/-/zen-observable-ts-1.2.5.tgz", + "integrity": "sha512-QZWQekv6iB72Naeake9hS1KxHlotfRpe+WGNbNx5/ta+R3DNjVO2bswf63gXlWDcs+EMd7XY8HfVQyP1X6T4Zg==", + "license": "MIT", + "dependencies": { + "zen-observable": "0.8.15" + } + } + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/package.json b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/package.json new file mode 100644 index 0000000000..f29c59e15c --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/package.json @@ -0,0 +1,22 @@ +{ + "name": "@wormhole-foundation/wormhole-sui-integration-test", + "version": "0.0.1", + "description": "Wormhole Sui Integration Test", + "main": "index.js", + "license": "MIT", + "dependencies": { + "@certusone/wormhole-sdk": "^0.9.12", + "@mysten/sui.js": "^0.32.2", + "chai": "^4.3.7", + "mocha": "^10.2.0", + "prettier": "^2.8.7", + "ts-mocha": "^10.0.0", + "ts-node": "^10.9.1", + "typescript": "^5.0.4" + }, + "devDependencies": { + "@types/chai": "^4.3.4", + "@types/mocha": "^10.0.1", + "@types/node": "^18.15.11" + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/run_integration_test.sh b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/run_integration_test.sh new file mode 100755 index 0000000000..80da863836 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/run_integration_test.sh @@ -0,0 +1,35 @@ +#/bin/bash + +pgrep -f sui > /dev/null +if [ $? -eq 0 ]; then + echo "sui local validator already running" + exit 1; +fi + +TEST_DIR=$(dirname $0) +SUI_CONFIG=$TEST_DIR/sui_config + +### Remove databases generated by localnet +rm -rf $SUI_CONFIG/*_db + +### Start local node +echo "$(date) :: starting localnet" +sui start --network.config $SUI_CONFIG/network.yaml > /dev/null 2>&1 & +sleep 1 + +echo "$(date) :: deploying wormhole and token bridge" +cd $TEST_DIR/.. +bash scripts/deploy.sh devnet \ + -k AGA20wtGcwbcNAG4nwapbQ5wIuXwkYQEWFUoSVAxctHb > deploy.out 2>&1 +cd testing + +## run contract tests here +echo "$(date) :: running tests" +pnpm exec ts-mocha -t 1000000 $TEST_DIR/js/*.ts + +# nuke +echo "$(date) :: done" +pkill sui + +# remove databases generated by localnet +rm -rf $SUI_CONFIG/*_db diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/scripts/upgrade-token-bridge.ts b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/scripts/upgrade-token-bridge.ts new file mode 100644 index 0000000000..605128dddb --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/scripts/upgrade-token-bridge.ts @@ -0,0 +1,300 @@ +import * as mock from "@certusone/wormhole-sdk/lib/cjs/mock"; +import { + RawSigner, + SUI_CLOCK_OBJECT_ID, + TransactionBlock, + fromB64, + normalizeSuiObjectId, + JsonRpcProvider, + Ed25519Keypair, + testnetConnection, +} from "@mysten/sui.js"; +import { execSync } from "child_process"; +import { resolve } from "path"; +import * as fs from "fs"; + +const GOVERNANCE_EMITTER = + "0000000000000000000000000000000000000000000000000000000000000004"; + +const TOKEN_BRIDGE_STATE_ID = + "0x32422cb2f929b6a4e3f81b4791ea11ac2af896b310f3d9442aa1fe924ce0bab4"; +const WORMHOLE_STATE_ID = + "0x69ae41bdef4770895eb4e7aaefee5e4673acc08f6917b4856cf55549c4573ca8"; + +async function main() { + const guardianPrivateKey = process.env.TESTNET_GUARDIAN_PRIVATE_KEY; + if (guardianPrivateKey === undefined) { + throw new Error("TESTNET_GUARDIAN_PRIVATE_KEY unset in environment"); + } + + const walletPrivateKey = process.env.TESTNET_WALLET_PRIVATE_KEY; + if (walletPrivateKey === undefined) { + throw new Error("TESTNET_WALLET_PRIVATE_KEY unset in environment"); + } + + const provider = new JsonRpcProvider(testnetConnection); + const wallet = new RawSigner( + Ed25519Keypair.fromSecretKey( + Buffer.from(walletPrivateKey, "base64").subarray(1) + ), + provider + ); + + const dstTokenBridgePath = resolve(`${__dirname}/../../token_bridge`); + + // Build for digest. + const { modules, dependencies, digest } = + buildForBytecodeAndDigest(dstTokenBridgePath); + console.log("dependencies", dependencies); + console.log("digest", digest.toString("hex")); + + // We will use the signed VAA when we execute the upgrade. + const guardians = new mock.MockGuardians(0, [guardianPrivateKey]); + + const timestamp = 12345678; + const governance = new mock.GovernanceEmitter(GOVERNANCE_EMITTER); + const published = governance.publishWormholeUpgradeContract( + timestamp, + 2, + "0x" + digest.toString("hex") + ); + const moduleName = Buffer.alloc(32); + moduleName.write("TokenBridge", 32 - "TokenBridge".length); + published.write(moduleName.toString(), 84 - 33); + published.writeUInt16BE(21, 84); + published.writeUInt8(2, 83); + //message.writeUInt8(1, 83); + published.writeUInt16BE(21, published.length - 34); + + const signedVaa = guardians.addSignatures(published, [0]); + console.log("Upgrade VAA:", signedVaa.toString("hex")); + + // // And execute upgrade with governance VAA. + // const upgradeResults = await upgradeTokenBridge( + // wallet, + // TOKEN_BRIDGE_STATE_ID, + // WORMHOLE_STATE_ID, + // modules, + // dependencies, + // signedVaa + // ); + + // console.log("tx digest", upgradeResults.digest); + // console.log("tx effects", JSON.stringify(upgradeResults.effects!)); + // console.log("tx events", JSON.stringify(upgradeResults.events!)); + + // TODO: grab new package ID from the events above. Do not rely on the RPC + // call because it may give you a stale package ID after the upgrade. + + const migrateResults = await migrateTokenBridge( + wallet, + TOKEN_BRIDGE_STATE_ID, + WORMHOLE_STATE_ID, + signedVaa + ); + console.log("tx digest", migrateResults.digest); + console.log("tx effects", JSON.stringify(migrateResults.effects!)); + console.log("tx events", JSON.stringify(migrateResults.events!)); +} + +main(); + +// Yeah buddy. + +function buildForBytecodeAndDigest(packagePath: string) { + const buildOutput: { + modules: string[]; + dependencies: string[]; + digest: number[]; + } = JSON.parse( + execSync( + `sui move build --dump-bytecode-as-base64 -p ${packagePath} 2> /dev/null`, + { encoding: "utf-8" } + ) + ); + return { + modules: buildOutput.modules.map((m: string) => Array.from(fromB64(m))), + dependencies: buildOutput.dependencies.map((d: string) => + normalizeSuiObjectId(d) + ), + digest: Buffer.from(buildOutput.digest), + }; +} + +async function getPackageId( + provider: JsonRpcProvider, + stateId: string +): Promise { + const state = await provider + .getObject({ + id: stateId, + options: { + showContent: true, + }, + }) + .then((result) => { + if (result.data?.content?.dataType == "moveObject") { + return result.data.content.fields; + } + + throw new Error("not move object"); + }); + + if ("upgrade_cap" in state) { + return state.upgrade_cap.fields.package; + } + + throw new Error("upgrade_cap not found"); +} + +async function upgradeTokenBridge( + signer: RawSigner, + tokenBridgeStateId: string, + wormholeStateId: string, + modules: number[][], + dependencies: string[], + signedVaa: Buffer +) { + const tokenBridgePackage = await getPackageId( + signer.provider, + tokenBridgeStateId + ); + const wormholePackage = await getPackageId(signer.provider, wormholeStateId); + + const tx = new TransactionBlock(); + + const [verifiedVaa] = tx.moveCall({ + target: `${wormholePackage}::vaa::parse_and_verify`, + arguments: [ + tx.object(wormholeStateId), + tx.pure(Array.from(signedVaa)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + const [decreeTicket] = tx.moveCall({ + target: `${tokenBridgePackage}::upgrade_contract::authorize_governance`, + arguments: [tx.object(tokenBridgeStateId)], + }); + const [decreeReceipt] = tx.moveCall({ + target: `${wormholePackage}::governance_message::verify_vaa`, + arguments: [tx.object(wormholeStateId), verifiedVaa, decreeTicket], + typeArguments: [ + `${tokenBridgePackage}::upgrade_contract::GovernanceWitness`, + ], + }); + + // Authorize upgrade. + const [upgradeTicket] = tx.moveCall({ + target: `${tokenBridgePackage}::upgrade_contract::authorize_upgrade`, + arguments: [tx.object(tokenBridgeStateId), decreeReceipt], + }); + + // Build and generate modules and dependencies for upgrade. + const [upgradeReceipt] = tx.upgrade({ + modules, + dependencies, + packageId: tokenBridgePackage, + ticket: upgradeTicket, + }); + + // Commit upgrade. + tx.moveCall({ + target: `${tokenBridgePackage}::upgrade_contract::commit_upgrade`, + arguments: [tx.object(tokenBridgeStateId), upgradeReceipt], + }); + + // Cannot auto compute gas budget, so we need to configure it manually. + // Gas ~215m. + //tx.setGasBudget(1_000_000_000n); + + return signer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} + +async function migrateTokenBridge( + signer: RawSigner, + tokenBridgeStateId: string, + wormholeStateId: string, + signedUpgradeVaa: Buffer +) { + const tokenBridgePackage = await getPackageId( + signer.provider, + tokenBridgeStateId + ); + const wormholePackage = await getPackageId(signer.provider, wormholeStateId); + + const tx = new TransactionBlock(); + + const [verifiedVaa] = tx.moveCall({ + target: `${wormholePackage}::vaa::parse_and_verify`, + arguments: [ + tx.object(wormholeStateId), + tx.pure(Array.from(signedUpgradeVaa)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + const [decreeTicket] = tx.moveCall({ + target: `${tokenBridgePackage}::upgrade_contract::authorize_governance`, + arguments: [tx.object(tokenBridgeStateId)], + }); + const [decreeReceipt] = tx.moveCall({ + target: `${wormholePackage}::governance_message::verify_vaa`, + arguments: [tx.object(wormholeStateId), verifiedVaa, decreeTicket], + typeArguments: [ + `${tokenBridgePackage}::upgrade_contract::GovernanceWitness`, + ], + }); + tx.moveCall({ + target: `${tokenBridgePackage}::migrate::migrate`, + arguments: [tx.object(tokenBridgeStateId), decreeReceipt], + }); + + return signer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} + +function setUpWormholeDirectory( + srcWormholePath: string, + dstWormholePath: string +) { + fs.cpSync(srcWormholePath, dstWormholePath, { recursive: true }); + + // Remove irrelevant files. This part is not necessary, but is helpful + // for debugging a clean package directory. + const removeThese = [ + "Move.devnet.toml", + "Move.lock", + "Makefile", + "README.md", + "build", + ]; + for (const basename of removeThese) { + fs.rmSync(`${dstWormholePath}/${basename}`, { + recursive: true, + force: true, + }); + } + + // Fix Move.toml file. + const moveTomlPath = `${dstWormholePath}/Move.toml`; + const moveToml = fs.readFileSync(moveTomlPath, "utf-8"); + fs.writeFileSync( + moveTomlPath, + moveToml.replace(`wormhole = "_"`, `wormhole = "0x0"`), + "utf-8" + ); +} + +function cleanUpPackageDirectory(packagePath: string) { + fs.rmSync(packagePath, { recursive: true, force: true }); +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/scripts/upgrade-wormhole.ts b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/scripts/upgrade-wormhole.ts new file mode 100644 index 0000000000..82d26b0f72 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/scripts/upgrade-wormhole.ts @@ -0,0 +1,267 @@ +import * as mock from "@certusone/wormhole-sdk/lib/cjs/mock"; +import { + RawSigner, + SUI_CLOCK_OBJECT_ID, + TransactionBlock, + fromB64, + normalizeSuiObjectId, + JsonRpcProvider, + Ed25519Keypair, + testnetConnection, +} from "@mysten/sui.js"; +import { execSync } from "child_process"; +import { resolve } from "path"; +import * as fs from "fs"; + +const GOVERNANCE_EMITTER = + "0000000000000000000000000000000000000000000000000000000000000004"; + +const WORMHOLE_STATE_ID = + "0x69ae41bdef4770895eb4e7aaefee5e4673acc08f6917b4856cf55549c4573ca8"; + +async function main() { + const guardianPrivateKey = process.env.TESTNET_GUARDIAN_PRIVATE_KEY; + if (guardianPrivateKey === undefined) { + throw new Error("TESTNET_GUARDIAN_PRIVATE_KEY unset in environment"); + } + + const walletPrivateKey = process.env.TESTNET_WALLET_PRIVATE_KEY; + if (walletPrivateKey === undefined) { + throw new Error("TESTNET_WALLET_PRIVATE_KEY unset in environment"); + } + + const provider = new JsonRpcProvider(testnetConnection); + const wallet = new RawSigner( + Ed25519Keypair.fromSecretKey( + Buffer.from(walletPrivateKey, "base64").subarray(1) + ), + provider + ); + + const srcWormholePath = resolve(`${__dirname}/../../wormhole`); + const dstWormholePath = resolve(`${__dirname}/wormhole`); + + // Stage build(s). + setUpWormholeDirectory(srcWormholePath, dstWormholePath); + + // Build for digest. + const { modules, dependencies, digest } = + buildForBytecodeAndDigest(dstWormholePath); + + // We will use the signed VAA when we execute the upgrade. + const guardians = new mock.MockGuardians(0, [guardianPrivateKey]); + + const timestamp = 12345678; + const governance = new mock.GovernanceEmitter(GOVERNANCE_EMITTER); + const published = governance.publishWormholeUpgradeContract( + timestamp, + 2, + "0x" + digest.toString("hex") + ); + published.writeUInt16BE(21, published.length - 34); + + const signedVaa = guardians.addSignatures(published, [0]); + console.log("Upgrade VAA:", signedVaa.toString("hex")); + + // And execute upgrade with governance VAA. + const upgradeResults = await buildAndUpgradeWormhole( + wallet, + WORMHOLE_STATE_ID, + modules, + dependencies, + signedVaa + ); + + console.log("tx digest", upgradeResults.digest); + console.log("tx effects", JSON.stringify(upgradeResults.effects!)); + console.log("tx events", JSON.stringify(upgradeResults.events!)); + + // TODO: grab new package ID from the events above. Do not rely on the RPC + // call because it may give you a stale package ID after the upgrade. + + // const migrateResults = await migrateWormhole( + // wallet, + // WORMHOLE_STATE_ID, + // signedVaa + // ); + // console.log("tx digest", migrateResults.digest); + // console.log("tx effects", JSON.stringify(migrateResults.effects!)); + // console.log("tx events", JSON.stringify(migrateResults.events!)); + + // Clean up. + cleanUpPackageDirectory(dstWormholePath); +} + +main(); + +// Yeah buddy. + +function buildForBytecodeAndDigest(packagePath: string) { + const buildOutput: { + modules: string[]; + dependencies: string[]; + digest: number[]; + } = JSON.parse( + execSync( + `sui move build --dump-bytecode-as-base64 -p ${packagePath} 2> /dev/null`, + { encoding: "utf-8" } + ) + ); + return { + modules: buildOutput.modules.map((m: string) => Array.from(fromB64(m))), + dependencies: buildOutput.dependencies.map((d: string) => + normalizeSuiObjectId(d) + ), + digest: Buffer.from(buildOutput.digest), + }; +} + +async function getPackageId( + provider: JsonRpcProvider, + stateId: string +): Promise { + const state = await provider + .getObject({ + id: stateId, + options: { + showContent: true, + }, + }) + .then((result) => { + if (result.data?.content?.dataType == "moveObject") { + return result.data.content.fields; + } + + throw new Error("not move object"); + }); + + if ("upgrade_cap" in state) { + return state.upgrade_cap.fields.package; + } + + throw new Error("upgrade_cap not found"); +} + +async function buildAndUpgradeWormhole( + signer: RawSigner, + wormholeStateId: string, + modules: number[][], + dependencies: string[], + signedVaa: Buffer +) { + const wormholePackage = await getPackageId(signer.provider, wormholeStateId); + + const tx = new TransactionBlock(); + + const [verifiedVaa] = tx.moveCall({ + target: `${wormholePackage}::vaa::parse_and_verify`, + arguments: [ + tx.object(wormholeStateId), + tx.pure(Array.from(signedVaa)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + const [decreeTicket] = tx.moveCall({ + target: `${wormholePackage}::upgrade_contract::authorize_governance`, + arguments: [tx.object(wormholeStateId)], + }); + const [decreeReceipt] = tx.moveCall({ + target: `${wormholePackage}::governance_message::verify_vaa`, + arguments: [tx.object(wormholeStateId), verifiedVaa, decreeTicket], + typeArguments: [`${wormholePackage}::upgrade_contract::GovernanceWitness`], + }); + + // Authorize upgrade. + const [upgradeTicket] = tx.moveCall({ + target: `${wormholePackage}::upgrade_contract::authorize_upgrade`, + arguments: [tx.object(wormholeStateId), decreeReceipt], + }); + + // Build and generate modules and dependencies for upgrade. + const [upgradeReceipt] = tx.upgrade({ + modules, + dependencies, + packageId: wormholePackage, + ticket: upgradeTicket, + }); + + // Commit upgrade. + tx.moveCall({ + target: `${wormholePackage}::upgrade_contract::commit_upgrade`, + arguments: [tx.object(wormholeStateId), upgradeReceipt], + }); + + // Cannot auto compute gas budget, so we need to configure it manually. + // Gas ~215m. + //tx.setGasBudget(1_000_000_000n); + + return signer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} + +async function migrateWormhole( + signer: RawSigner, + wormholeStateId: string, + signedUpgradeVaa: Buffer +) { + const contractPackage = await getPackageId(signer.provider, wormholeStateId); + + const tx = new TransactionBlock(); + tx.moveCall({ + target: `${contractPackage}::migrate::migrate`, + arguments: [ + tx.object(wormholeStateId), + tx.pure(Array.from(signedUpgradeVaa)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + return signer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + }, + }); +} + +function setUpWormholeDirectory( + srcWormholePath: string, + dstWormholePath: string +) { + fs.cpSync(srcWormholePath, dstWormholePath, { recursive: true }); + + // Remove irrelevant files. This part is not necessary, but is helpful + // for debugging a clean package directory. + const removeThese = [ + "Move.devnet.toml", + "Move.lock", + "Makefile", + "README.md", + "build", + ]; + for (const basename of removeThese) { + fs.rmSync(`${dstWormholePath}/${basename}`, { + recursive: true, + force: true, + }); + } + + // Fix Move.toml file. + const moveTomlPath = `${dstWormholePath}/Move.toml`; + const moveToml = fs.readFileSync(moveTomlPath, "utf-8"); + fs.writeFileSync( + moveTomlPath, + moveToml.replace(`wormhole = "_"`, `wormhole = "0x0"`), + "utf-8" + ); +} + +function cleanUpPackageDirectory(packagePath: string) { + fs.rmSync(packagePath, { recursive: true, force: true }); +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/client.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/client.yaml new file mode 100644 index 0000000000..33371df956 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/client.yaml @@ -0,0 +1,12 @@ +--- +keystore: + File: sui_config/sui.keystore +envs: + - alias: localnet + rpc: "http://0.0.0.0:9000" + ws: ~ + - alias: devnet + rpc: "https://fullnode.devnet.sui.io:443" + ws: ~ +active_env: localnet +active_address: "0xed867315e3f7c83ae82e6d5858b6a6cc57c291fd84f7509646ebc8162169cf96" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/fullnode.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/fullnode.yaml new file mode 100644 index 0000000000..fc71e910e6 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/fullnode.yaml @@ -0,0 +1,53 @@ +--- +protocol-key-pair: + value: W+hPTVWhdFgzHs3YuRHV6gLfgFhHA1WG0pisIXiN8E8= +worker-key-pair: + value: AApEvpZE1O+2GMqZ1AbRE3+Kmgr1O5mdsMZ6I/gLpVSy +account-key-pair: + value: AN7ZHgjN8G7Nw7Q8NtY9TisPBjmEYpdUzbczjqR98XLh +network-key-pair: + value: AAnB6/zZooq4xDtB7oM/GeTSCh5tBxKAyJwWOMPlEJ4R +db-path: sui_config/authorities_db/full_node_db +network-address: /ip4/127.0.0.1/tcp/36683/http +json-rpc-address: "0.0.0.0:9000" +metrics-address: "127.0.0.1:35915" +admin-interface-port: 44319 +enable-event-processing: true +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: ~ +p2p-config: + listen-address: "127.0.0.1:38187" + external-address: /ip4/127.0.0.1/udp/38187 + seed-peers: + - peer-id: ce60e3077e02a3683436af450f3a4511b4c40b158956637caf9ccf11391e7e10 + address: /ip4/127.0.0.1/udp/44061 + - peer-id: 5f0f42cb3fb20dd577703388320964f9351d997313c04a032247060d214b2e71 + address: /ip4/127.0.0.1/udp/46335 + - peer-id: 6d9095130b1536c0c9218ea9feb0f36685a6fa0b3b1e67d256cc4fb340a48d69 + address: /ip4/127.0.0.1/udp/32965 + - peer-id: b2915bf787845a55c24e18fdc162a575eb02d23bae3f9e566d7c51ebcfeb4a42 + address: /ip4/127.0.0.1/udp/39889 +genesis: + genesis-file-location: sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/genesis.blob b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/genesis.blob new file mode 100644 index 0000000000..0bf9f806bc Binary files /dev/null and b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/genesis.blob differ diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/network.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/network.yaml new file mode 100644 index 0000000000..37122d68f0 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/network.yaml @@ -0,0 +1,324 @@ +--- +validator_configs: + - protocol-key-pair: + value: VTDx4HjVmRBqdqBWg2zN+zcFE20io3CrBchGy/iV1lo= + worker-key-pair: + value: ABlC9PMmIQHjxila3AEOXDxwCSuodcvJh2Q5O5HIB00K + account-key-pair: + value: AIV4Ng6OYQf6irjVCZly5X7dSpdFpwoWtdAx9u4PANRl + network-key-pair: + value: AOqJl2rHMnroe26vjkkIuWGBD/y6HzQG6MK5bC9njF0s + db-path: sui_config/authorities_db/99f25ef61f80 + network-address: /ip4/127.0.0.1/tcp/36459/http + json-rpc-address: "127.0.0.1:38133" + metrics-address: "127.0.0.1:44135" + admin-interface-port: 33917 + consensus-config: + address: /ip4/127.0.0.1/tcp/41459/http + db-path: sui_config/consensus_db/99f25ef61f80 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/44689/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/33219/http + network_admin_server: + primary_network_admin_server_port: 33945 + worker_network_admin_server_base_port: 38081 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:44061" + external-address: /ip4/127.0.0.1/udp/44061 + genesis: + genesis-file-location: sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false + - protocol-key-pair: + value: avYcyVgYMXTyaUYh9IRwLK0gSzl7YF6ZQDAbrS1Bhvo= + worker-key-pair: + value: AGsxCVxeIZ6fscvGECzV93Hi4JkqM4zMYEA8wBGfXQrz + account-key-pair: + value: AF9cOMxTRAUTOws2M8W5slHf41HITA+M3nqXHT6nlH6S + network-key-pair: + value: ALH/8qz2YlwAuxY/hOvuXiglYq0e4LLU1/lyf5uKgPY8 + db-path: sui_config/authorities_db/8dcff6d15504 + network-address: /ip4/127.0.0.1/tcp/33355/http + json-rpc-address: "127.0.0.1:39573" + metrics-address: "127.0.0.1:45851" + admin-interface-port: 35739 + consensus-config: + address: /ip4/127.0.0.1/tcp/42959/http + db-path: sui_config/consensus_db/8dcff6d15504 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/37001/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/39831/http + network_admin_server: + primary_network_admin_server_port: 39853 + worker_network_admin_server_base_port: 36429 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:46335" + external-address: /ip4/127.0.0.1/udp/46335 + genesis: + genesis-file-location: sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false + - protocol-key-pair: + value: OXnx3yM1C/ppgnDMx/o1d49fJs7E05kq11mXNae/O+I= + worker-key-pair: + value: AHXs8DP7EccyxtxAGq/m33LgvOApXs4JStH3PLAe9vGw + account-key-pair: + value: AC8vF9E3QYf0aTyBZWlSzJJXETvV5vYkOtEJl+DWQMlk + network-key-pair: + value: AOapcKU6mW5SopFM6eBSiXgbuPJTz11CiEqM+SJGIEOF + db-path: sui_config/authorities_db/addeef94d898 + network-address: /ip4/127.0.0.1/tcp/34633/http + json-rpc-address: "127.0.0.1:38025" + metrics-address: "127.0.0.1:43451" + admin-interface-port: 36793 + consensus-config: + address: /ip4/127.0.0.1/tcp/40307/http + db-path: sui_config/consensus_db/addeef94d898 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/37445/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/43943/http + network_admin_server: + primary_network_admin_server_port: 39611 + worker_network_admin_server_base_port: 38377 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:32965" + external-address: /ip4/127.0.0.1/udp/32965 + genesis: + genesis-file-location: sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false + - protocol-key-pair: + value: CyNkjqNVr3HrHTH7f/NLs7u5lUHJzuPAw0PqMTD2y2s= + worker-key-pair: + value: AHd6qvbBv7bTCGGoD1TUR5dOGnwOnYvhHV9ryCUp7rmZ + account-key-pair: + value: ALSCvWwsVryGIwq+n4f9bIPCRqsooGodE/vDaVCSLfjE + network-key-pair: + value: APFCK1pRVxn9PDt+KzWx52+EY5nzaZZU2GF9RZoQY58Y + db-path: sui_config/authorities_db/b3fd5efb5c87 + network-address: /ip4/127.0.0.1/tcp/33953/http + json-rpc-address: "127.0.0.1:35625" + metrics-address: "127.0.0.1:37813" + admin-interface-port: 46405 + consensus-config: + address: /ip4/127.0.0.1/tcp/43213/http + db-path: sui_config/consensus_db/b3fd5efb5c87 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/46745/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/38817/http + network_admin_server: + primary_network_admin_server_port: 34929 + worker_network_admin_server_base_port: 37447 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ + enable-event-processing: false + enable-index-processing: true + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:39889" + external-address: /ip4/127.0.0.1/udp/39889 + genesis: + genesis-file-location: sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false +account_keys: [] +genesis: AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAINRCoP2A/TVqNfPAfndpv33WFbqdGt8UUaAP28Xiv8m4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyjYfxIcBAAAAAAAAAAAAAAAAAIsN7KKhcSvE07253vGyxVXEMi5V5Pm7Yp6ooavX4pSFYCIBTuWN2hv40J8J0sdQMxg6MAAAAQAAAAAAAwAQAAAAAAABAAIAAwAAASA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyCBz3ecai2p3AnFvhrBoUGQrtgb/zLrK42Tw56HwaBu5VQEAAQAAAAACMQABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAAAsDYmNzXKEc6wsGAAAABgEAAgMCBgUIBwcPDQgcIAw8BAAAAAEAAQEAAQYJAAEKAgNiY3MIdG9fYnl0ZXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQABAgAABGhhc2hqoRzrCwYAAAAGAQACAwIKBQwDBw8XCCYgDEYIAAAAAQAAAAACAAAAAQoCBGhhc2gIc2hhMl8yNTYIc2hhM18yNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQABAgABAQIAAAVhc2NpaZcGoRzrCwYAAAALAQAEAgQOAxJUBGYIBW47B6kByAEI8QIgBpEDCgqbAwsMpgO6Ag3gBQQABQAQAAIHAAAABwABAQcBAAAACAABAAAUAgMAABUCBAAAAwUGAAASBwgAABEJAQAADgUKAAAEBQsAAAoDAgAABgEAAAANAAYAAAsABgABCQ0OAQABDAwGAQABDwgNAQABEw4NAQANAwwDDgMPAwECAQgBAQoCAQgAAQsCAQgAAQYIAAEBAgcIAAgBAAEHCAABAwEGCgIBBgsCAQkAAQsCAQkAAQkAAgMDBENoYXIGT3B0aW9uBlN0cmluZxhhbGxfY2hhcmFjdGVyc19wcmludGFibGUIYXNfYnl0ZXMFYXNjaWkEYnl0ZQVieXRlcwRjaGFyDGRlc3Ryb3lfc29tZQppbnRvX2J5dGVzEWlzX3ByaW50YWJsZV9jaGFyB2lzX3NvbWUNaXNfdmFsaWRfY2hhcgZsZW5ndGgEbm9uZQZvcHRpb24IcG9wX2NoYXIJcHVzaF9jaGFyBHNvbWUGc3RyaW5nCnRyeV9zdHJpbmcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAABAAAAAAAAAgEHCgIBAgEGAgABAAAICQoAEQoEBAUGBwAnCwASAQIBAQAABAwLABECDAEOATgABAcFCQcAJwsBOAECAgEAAA8eDgBBAAwCBgAAAAAAAAAADAEoCgEKAiMEGQULDgAKAUIAFBEKIAQUOAICCwEGAQAAAAAAAAAWDAEFBSgLABIAOAMCAwEAAA8gCgAQAEEADAIGAAAAAAAAAAAMASgKAQoCIwQdBQwKABAACgFCABQRCyAEGAsAAQkCCwEGAQAAAAAAAAAWDAEFBigIAgQBAAAIBwsADwAOARABFEQAAgUBAAAIBQsADwBFABIBAgYBAAAIBAsAEQdBAAIHAQAACAMLABAAAggBAAAIAwsAEwACCQEAAAgDCwATAQIKAQAACAQLADF/JQILAQAABg0KADEgJgQJCwAxfiUMAQULCQwBCwECAAABAAAFZGVidWd0oRzrCwYAAAAGAQACAwILBQ0FBxIeCDAgDFAIAAAAAQABAQAAAgEBAAEGCQAABWRlYnVnBXByaW50EXByaW50X3N0YWNrX3RyYWNlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQIAAQECAAAGb3B0aW9u8QihHOsLBgAAAA0BAAQCBAYDCngEggEOBZABhwEHlwLbAQjyAyAGkgQUCqYEBwutBAIMrwSABA2vCAIOsQgCAA8AFgAABwEAAAAOAAEBAAARAgEBAAAMAwQBAAANAwQBAAAEBQQBAAABAwYBAAADBQYBAAAKBwIBAwAJCAABAAAICQIBAAACCQoBAAASCAIBAAATCAEBAAAHCwIBAgAGAQIBAAAFAQABAAAUAQwBAAEEDgQBAAELDQQBAAEQAgwBABMCEgIRAgMCAAIBAgICAAELAAEJAAEJAAEGCwABCQABAQIGCwABCQAGCQABBgkAAgYLAAEJAAkAAgcLAAEJAAkAAQcLAAEJAAEHCQACCwABCQAJAAEKCQABBgoJAAIGCgkABgkAAgYJAAYKCQACCQAGCgkAAQcKCQACCQAHCgkAAwsAAQkACwABCQAHCgkAAgkACgkABk9wdGlvbgZib3Jyb3cKYm9ycm93X211dBNib3Jyb3dfd2l0aF9kZWZhdWx0CGNvbnRhaW5zDGRlc3Ryb3lfbm9uZQxkZXN0cm95X3NvbWUUZGVzdHJveV93aXRoX2RlZmF1bHQHZXh0cmFjdARmaWxsEGdldF93aXRoX2RlZmF1bHQIaXNfZW1wdHkHaXNfbm9uZQdpc19zb21lBG5vbmUGb3B0aW9uCXNpbmdsZXRvbgRzb21lBHN3YXAMc3dhcF9vcl9maWxsBnRvX3ZlYwN2ZWMGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAABAAAAAAAAwgBAAQAAAAAAAACARUKCQAAAgABAAAAA0ACAAAAAAAAAAA5AAIBAQAAAAQLADgAOQACAgEAAAAECwA3ADgBAgMBAAAABQsANwA4ASACBAEAAAAFCwA3AAsBOAICBQEAAAANCgA4AwQEBQgLAAEHAScLADcABgAAAAAAAAAAQgICBgEAAA8TCwA3AAwDCgM4AQQLCwMBCwEMAgURCwEBCwMGAAAAAAAAAABCAgwCCwICBwEAABASCwA3AAwDCgM4AQQLCwMBCwEMAgUQCwMGAAAAAAAAAABCAhQMAgsCAggBAAAREAsANgAMAgoCLjgBBAgFDAsCAQcAJwsCCwFEAgIJAQAAAA0KAC44AwQFBQkLAAEHAScLADYARQICCgEAAAAOCgAuOAMEBQUJCwABBwEnCwA2AAYAAAAAAAAAAEMCAgsBAAASFAoALjgDBAUFCQsAAQcBJwsANgAMAwoDRQIMAgsDCwFEAgsCAgwBAAATFQsANgAMBAoELjgBBAo4BAwCBQ4KBEUCOAUMAgsCDAMLBAsBRAILAwINAQAAFA8LADoADAMNAy44AQQKCwEMAgUNDQNFAgwCCwICDgEAABQQDgA4AwQEBQYHAScLADoADAINAkUCDAELAkYCAAAAAAAAAAALAQIPAQAAAAoOADgGBAQFBgcAJwsAOgBGAgAAAAAAAAAAAhABAAAAAwsAOgACAAAAAgAGc3RyaW5n+QehHOsLBgAAAAsBAAgCCA4DFnIEiAEIBZABeweLAvgBCIMEIAajBBQKtwQGDL0EhQMNwgcCABMABAARABgAAQcAAQEHAAIABwEAAAAXAAEAAAYCAQAAFQECAAAWAAMAAAUEBQAADgQGAAAPBAcAAAIICQAAAwoJAAAICwkAABQMAQAABw0HAAAJBQYAAAsOBgAADA8AAAAKEAcAAQ0CAAABEwACAAIQCRIBAAISERIBAAMCFQkBAAMOFAYBABMBEgEVExQTAQoCAQgAAQgBAQsCAQgAAQYIAAEGCgIBAQEDAgcIAAgAAAIHCAAKAgMHCAADCAADBggAAwMCBggABggAAgYKAgMDBgoCAwMCBgoCBgoCAQkAAQsCAQkAAQIBBgoJAAIHCgkACgkACAEDAwMGCgIIAAgAAwUBAQEGCgIDBk9wdGlvbgZTdHJpbmcGYXBwZW5kC2FwcGVuZF91dGY4BWFzY2lpBWJ5dGVzCmZyb21fYXNjaWkIaW5kZXhfb2YGaW5zZXJ0E2ludGVybmFsX2NoZWNrX3V0ZjgRaW50ZXJuYWxfaW5kZXhfb2YZaW50ZXJuYWxfaXNfY2hhcl9ib3VuZGFyeRNpbnRlcm5hbF9zdWJfc3RyaW5nCmludG9fYnl0ZXMIaXNfZW1wdHkGbGVuZ3RoBG5vbmUGb3B0aW9uBHNvbWUGc3RyaW5nCnN1Yl9zdHJpbmcIdG9fYXNjaWkIdHJ5X3V0ZjgEdXRmOAZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAQAAAAAAAAADCAIAAAAAAAAAAAIBBQoCAAEAAAkJDgARDAQEBQYHACcLABIAAgEBAAAJBAsAERASAAICAQAACQQLABMAERECAwEAAAMMDgARDAQICwASADgADAEFCjgBDAELAQIEAQAACQMLABAAAgUBAAAJBAsAEAA4AgIGAQAACQQLABAAQRMCBwEAAAkHCwAPAA4BEAAUOAMCCAEAAAkFCwALAREAEQcCCQEAABY4CgAQAAwHCgEKB0ETJQQNCwcKARENDAMFEQsHAQkMAwsDBBQFGAsAAQcBJwoALhEGDAoKAAoBDAQuBgAAAAAAAAAACwQRCgwJCgALAQsKDAYMBS4LBQsGEQoMCA0JCwIRBw0JCwgRBwsJCwAVAgoBAAAXMAsAEAAMBgoGQRMMBwoCCwclBA8KAQoCJQwDBREJDAMLAwQYCgYKARENDAQFGgkMBAsEBCEKBgoCEQ0MBQUjCQwFCwUEJgUqCwYBBwEnCwYLAQsCEQ4SAAILAQAACQYLABAACwEQABEPAgwAAgANAAIADgACAA8AAgAAAAAGdmVjdG9ykQihHOsLBgAAAAgBAAIDAmYEaAQFbGEHzQGaAQjnAiAGhwMKDJED2AQAEQAFAAEBAAAJAgMBAAABBAUBAAALBgABAAACBwgBAAAKCQoBAAAEAQABAAAPCwABAAAOCgEBAAANCQABAAAADAABAAAIAg0BAAADDg0BAAAGDg8BAAAMBwoBAAAHEAABAAAQBwoBAAkKCwoAAQoJAAEGCgkAAQMCBgoJAAMBBgkAAgcKCQAJAAIHCgkAAwEHCQABBwoJAAEJAAMHCgkAAwMCBwoJAAoJAAEBAgYKCQAGCQACAQMDBwoJAAkAAwMDAwMCAwMDAwcKCQADBmFwcGVuZAZib3Jyb3cKYm9ycm93X211dAhjb250YWlucw1kZXN0cm95X2VtcHR5BWVtcHR5CGluZGV4X29mBmluc2VydAhpc19lbXB0eQZsZW5ndGgIcG9wX2JhY2sJcHVzaF9iYWNrBnJlbW92ZQdyZXZlcnNlCXNpbmdsZXRvbgRzd2FwC3N3YXBfcmVtb3ZlBnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAIAAAAAAAABAgABAQIAAgECAAMBAgAEAQIABQECAAYBAgAHAQIACAEAAAEHQAoAAAAAAAAAAAwBDQELAEQKCwECCQEAABEmCgAuQQoMAwoDBgAAAAAAAAAAIQQLCwABAgYAAAAAAAAAAAwCCwMGAQAAAAAAAAAXDAEKAgoBIwQjBRYKAAoCCgFHCgsCBgEAAAAAAAAAFgwCCwEGAQAAAAAAAAAXDAEFEQsAAQIKAQAAABENATgADgE4ASAEDAUHCgANAUUKRAoFAgsAAQsBRgoAAAAAAAAAAAILAQAAAAULAEEKBgAAAAAAAAAAIQIMAQAAEiEGAAAAAAAAAAAMAgoAQQoMAwoCCgMjBBsFCgoACgJCCgoBIQQWCwABCwEBCAILAgYBAAAAAAAAABYMAgUFCwABCwEBCQINAQAAEiMGAAAAAAAAAAAMAgoAQQoMAwoCCgMjBBwFCgoACgJCCgoBIQQXCwABCwEBCAsCAgsCBgEAAAAAAAAAFgwCBQULAAELAQEJBgAAAAAAAAAAAg4BAAATJQoALkEKDAQKAQoEJgQMCwABBwAnCwQGAQAAAAAAAAAXDAQKAQoEIwQiBRUKAAwDCgEMAgsBBgEAAAAAAAAAFgwBCwMLAgoBRwoFEAsARQoCDwEAAAMgCgAuQQoMAwoCCgMkBAwLAAEHACcKAAsBRAoKAgoDIwQdBRQKAAoCCgNHCgsCBgEAAAAAAAAAFgwCBQ8LAAECEAEAAAMXCgAuOAEgBAYFCgsAAQcAJwoALkEKBgEAAAAAAAAAFwwCCgALAQsCRwoLAEUKAgAHYWRkcmVzc2WhHOsLBgAAAAYBAAIDAgUFBwMHCg8IGSAMORAAAAABAAEAAAEDB2FkZHJlc3MGbGVuZ3RoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQAAAAIGIAAAAAAAAAACAAl0eXBlX25hbWWMBKEc6wsGAAAACgEABgIGCAMOKQU3LAdjeQjcASAG/AEHCoMCBgyJAtMBDdwDAgANAAIABAABBwACAAcAAAYAAQEAAAUCAwAABwIEAAAIAgQAAAkBBAABCgAGAAIDAwcAAgwJBAAAAQgAAQYIAAEGCAEBCAEECgIDAwYKAgEDAQYKAgECAQoCBQIGAgMKAgYKAgZTdHJpbmcIVHlwZU5hbWUHYWRkcmVzcwhhc19ieXRlcwVhc2NpaQ1ib3Jyb3dfc3RyaW5nA2dldAtnZXRfYWRkcmVzcwpnZXRfbW9kdWxlC2ludG9fc3RyaW5nBmxlbmd0aARuYW1lBnN0cmluZwl0eXBlX25hbWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIBOgoCAQAAAgELCAEAAQIAAQEAAAADCwAQAAICAQAABSERBQYCAAAAAAAAABgMAwsAEAARBgwEBwEMAQYAAAAAAAAAAAwCCgIKAyMEHAURDQEKBAoCQggURAgLAgYBAAAAAAAAABYMAgUMCwQBCwERBwIDAQAACicRBQYCAAAAAAAAABgGAgAAAAAAAAAWDAMLABAAEQYMBQcBDAQKBQoDQggMAgcADAEKAg4BIgQgBRcNBAsCFEQICwMGAQAAAAAAAAAWDAMFDAsFAQsCAQsEEQcCBAEAAAAEDgAQABQCAAAACmJpdF92ZWN0b3KrBqEc6wsGAAAACgEAAgICBAMGIwUpJAdNbQi6ASAG2gEoCoICCAyKAu8DDfkFBAACAAAHAAAGAAEAAAcCAwAACQIDAAAIAgMAAAMEBQAABAYAAAAFBAAAAQMBCAACBwgAAwACBggAAwEBAQYIAAIKAQMBBwEFAwcBAwMDCUJpdFZlY3RvcgliaXRfZmllbGQKYml0X3ZlY3Rvcgxpc19pbmRleF9zZXQGbGVuZ3RoIGxvbmdlc3Rfc2V0X3NlcXVlbmNlX3N0YXJ0aW5nX2F0A25ldwNzZXQKc2hpZnRfbGVmdAV1bnNldAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAIAAAAAAAMIAQACAAAAAAADCAEAAAAAAAAAAwgABAAAAAAAAAACAgQDAQoBAAEAAAclCgAGAAAAAAAAAAAkBAUFBwcBJwoABwMjBAwFDgcBJwYAAAAAAAAAAAwCQAUAAAAAAAAAAAwBKAoCCgAjBCAFGA0BCUQFCwIGAQAAAAAAAAAWDAIFEigLAAsBEgACAQEAAAgUCgEKABAAQQUjBAcFCwsAAQcAJwsADwALAUMFDAIICwIVAgIBAAAIFAoBCgAQAEEFIwQHBQsLAAEHACcLAA8ACwFDBQwCCQsCFQIDAQAACVkKAQoAEAEUJgQhCgAQAEEFDAYGAAAAAAAAAAAMBAoECgYjBB4FEQoADwAKBEMFDAMJCwMVCwQGAQAAAAAAAAAWDAQFDAsAAQVYCgEMBQoFCgAQARQjBEEFKgoACgUMAi4LAhEEBDcKAAoFCgEXEQEFPAoACgUKARcRAgsFBgEAAAAAAAAAFgwFBSMKABABFAsBFwwFCgUKABABFCMEVgVOCgAKBRECCwUGAQAAAAAAAAAWDAUFRwsAAQIEAQAAAxEKAQoAEABBBSMEBwULCwABBwAnCwAQAAsBQgUUAgUBAAADBAsAEABBBQIGAQAAACUKAQoAEAEUIwQHBQsLAAEHACcKAQwCCgIKABABFCMEIQUUCgAKAhEEIAQcCwABBSELAgYBAAAAAAAAABYMAgUNCwILARcCAAEAAAANZml4ZWRfcG9pbnQzMtYEoRzrCwYAAAAKAQACAgIEAwYeBSQWBzp6CLQBIAbUAUQKmAIFDJ0CiQINpgQCAAQAAAcAAAcAAQAAAwABAAABAgMAAAIBAwAABQMBAAAGAwQAAgMIAAEDAgMDAQgAAQEBBAQBBAQEAAxGaXhlZFBvaW50MzIUY3JlYXRlX2Zyb21fcmF0aW9uYWwVY3JlYXRlX2Zyb21fcmF3X3ZhbHVlCmRpdmlkZV91NjQNZml4ZWRfcG9pbnQzMg1nZXRfcmF3X3ZhbHVlB2lzX3plcm8MbXVsdGlwbHlfdTY0BXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEEP//////////AAAAAAAAAAADCAEAAQAAAAAAAwgCAAIAAAAAAAMIAwACAAAAAAADCAQAAQAAAAAAAwgFAAIAAAAAAAACAQgDAAEAAAUUCwA1DgEQABQ1GDEgMAwCCgIHACUEDwURBwMnCwI0AgEBAAAFHQ4BEAAUBgAAAAAAAAAAIgQHBQkHBCcLADUxIC8OARAAFDUaDAIKAgcAJQQYBRoHAicLAjQCAgEAAAYwCgA1MUAvDAULATUxIC8MBAoEMgAAAAAAAAAAAAAAAAAAAAAiBA8FEQcBJwsFCwQaDAMKAzIAAAAAAAAAAAAAAAAAAAAAIgQcCAwCBSALAAYAAAAAAAAAACEMAgsCBCMFJQcFJwoDBwAlBCoFLAcFJwsDNBIAAgMBAAAHAwsAEgACBAEAAAcEDgAQABQCBQEAAAcGDgAQABQGAAAAAAAAAAAhAgAAAAcNZml4ZWRfcG9pbnQzMgxGaXhlZFBvaW50MzIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQZvcHRpb24GT3B0aW9uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEFYXNjaWkGU3RyaW5nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEFYXNjaWkEQ2hhcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCmJpdF92ZWN0b3IJQml0VmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEGc3RyaW5nBlN0cmluZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCXR5cGVfbmFtZQhUeXBlTmFtZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAMAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQAAAAAAAAApA2JhZ+wFoRzrCwYAAAALAQAIAggMAxRwBIQBDAWQAVIH4gG5AQibAyAGuwMKCsUDCAzNA+YBDbMFBAAEAAsAEgAVAAAMAAICBAADAQIAABEAAQAAAwIDAgcEAAUEBQIHBAAGBgcCBwQAEwYIAgcEAAcECQEHAAgECQIHBAAQCgsAAA8KCQAACgEDAAEDDgMCBwQBBQ8FAgcEAQYQBwIHBAEMDwkBBwENDwkCBwQBExAIAgcEAgkMAwACEQAMAAoNCw0MDQ8NDREODQEHCAIBCAADBwgACQAJAQACBggACQABBgkBAgcIAAkAAQcJAQEJAQEBAQYIAAEDAQgBAgkACQEDBwgBCQAJAQIGCAEJAAIHCAEJAAEJAAIIAQMDQmFnCVR4Q29udGV4dANVSUQDYWRkA2JhZwZib3Jyb3cKYm9ycm93X211dAhjb250YWlucxJjb250YWluc193aXRoX3R5cGUGZGVsZXRlDWRlc3Ryb3lfZW1wdHkNZHluYW1pY19maWVsZAdleGlzdHNfEGV4aXN0c193aXRoX3R5cGUCaWQIaXNfZW1wdHkGbGVuZ3RoA25ldwZvYmplY3QGcmVtb3ZlBHNpemUKdHhfY29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAACAg4IARQDAAEAAAMFCwAREQYAAAAAAAAAABIAAgEBAAADDgoADwALAQsCOAAKABABFAYBAAAAAAAAABYLAA8BFQICAQAAAwULABAACwE4AQIDAQAAAwULAA8ACwE4AgIEAQAACA8KAA8ACwE4AwwCCgAQARQGAQAAAAAAAAAXCwAPARULAgIFAQAAAwULABAACwE4BAIGAQAAAwULABAACwE4BQIHAQAAAwQLABABFAIIAQAAAwYLABABFAYAAAAAAAAAACECCQEAABIOCwATAAwCDAELAgYAAAAAAAAAACEECQULBwAnCwEREAIAAAABAANiY3OVD6Ec6wsGAAAACwEACgIKCgMUhwEEmwEYBbMBgwEHtgLeAgiUBUAG1AU3CosGBgyRBssIDdwOAgADAQMBCgEfAAIAAAcAAgEHAQAAAB4AAQEAAAgBAgAABgIBAAALAwQAAAwDBQAAFAMGAAATAwcAABIDCAAAFwMHAAAVAwkAABYDCgAAGgMBAAAbAwsAABkDDAAAGAMNAAANAw4AAA4DDwAAEQMQAAAQAxEAAA8DEgABHgABAQACCRMhAQACHRQhAQADHBUTAQAEBQEEAAQHEwcAFBQXBhYEFQQWBRUFFgYVBhYHFQcWCBUIAQYJAAEKAgEIAAEHCAABBQEBAQIBAwEEAQoFAQoBAQoKAgEKAwEKBAELAQEFAQsBAQEBCwEBAgELAQEDAQsBAQQAAQkAAQcKCQACCgIDAgECAwMCAwMEAgQEAwMCAwMDAwoFAwMDCgEDAwMKAgMDAwoKAgMDAwoDAwMDCgQBCwEBCQADQkNTBk9wdGlvbgdhZGRyZXNzA2JjcwVieXRlcwpmcm9tX2J5dGVzFGludG9fcmVtYWluZGVyX2J5dGVzBmxlbmd0aANuZXcEbm9uZQZvcHRpb24McGVlbF9hZGRyZXNzCXBlZWxfYm9vbBNwZWVsX29wdGlvbl9hZGRyZXNzEHBlZWxfb3B0aW9uX2Jvb2wQcGVlbF9vcHRpb25fdTEyOA9wZWVsX29wdGlvbl91NjQOcGVlbF9vcHRpb25fdTgJcGVlbF91MTI4CHBlZWxfdTY0B3BlZWxfdTgQcGVlbF92ZWNfYWRkcmVzcw1wZWVsX3ZlY19ib29sD3BlZWxfdmVjX2xlbmd0aA1wZWVsX3ZlY191MTI4DHBlZWxfdmVjX3U2NAtwZWVsX3ZlY191OA9wZWVsX3ZlY192ZWNfdTgHcmV2ZXJzZQRzb21lCHRvX2J5dGVzBnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAAKBQEACgEBAAoCAQAKCgIBAAoDAQAKBAEAAAIBBAoCAAEAABMDCwA4AAIBAQAAEwUNADgBCwASAAICAQAAAQcLABMADAENATgBCwECAwEAABYjCgAQAEEGERkmBAcFCwsAAQcAJ0AGAAAAAAAAAAAGAAAAAAAAAAAMAgwBCgIRGSMEHgUUDQEKAA8ARQZEBgsCBgEAAAAAAAAAFgwCBQ8LAAELAREYAgQBAAAXFQsAEQUMAgoCMQAhBAoJDAEFEwsCMQEhBA8FEQcBJwgMAQsBAgUBAAATDwoAEABBBgYBAAAAAAAAACYEBwULCwABBwAnCwAPAEUGAgYBAAAYKAoAEABBBgYIAAAAAAAAACYEBwULCwABBwAnBgAAAAAAAAAAMQAMAgwDCgIxQCMEJAUUCgAPAEUGNAwBCwMLAQoCLxYMAwsCMQgWDAIFDwsAAQsDAgcBAAAZKAoAEABBBgYQAAAAAAAAACYEBwULCwABBwAnMgAAAAAAAAAAAAAAAAAAAAAxAAwCDAMKAjGAIwQkBRQKAA8ARQY1DAELAwsBCgIvFgwDCwIxCBYMAgUPCwABCwMCCAEAABowBgAAAAAAAAAAMQAGAAAAAAAAAAAMAgwDDAQKAgYEAAAAAAAAACUECwUPCwABBwInCgAPAEUGNAwBCwIGAQAAAAAAAAAWDAILBAoBBn8AAAAAAAAAHAoDLxsMBAsBBoAAAAAAAAAAHAYAAAAAAAAAACEEJwUsCwMxBxYMAwUGCwABCwQCCQEAABsZCgARCAYAAAAAAAAAAAcDDAMMAQwCCgEKAiMEFQUMDQMKABEDRAQLAQYBAAAAAAAAABYMAQUHCwABCwMCCgEAABwZCgARCAYAAAAAAAAAAAcEDAMMAQwCCgEKAiMEFQUMDQMKABEERAULAQYBAAAAAAAAABYMAQUHCwABCwMCCwEAAB0ZCgARCAYAAAAAAAAAAAcFDAMMAQwCCgEKAiMEFQUMDQMKABEFRAYLAQYBAAAAAAAAABYMAQUHCwABCwMCDAEAAB4ZCgARCAYAAAAAAAAAAAcGDAMMAQwCCgEKAiMEFQUMDQMKABELRAELAQYBAAAAAAAAABYMAQUHCwABCwMCDQEAAB8ZCgARCAYAAAAAAAAAAAcHDAMMAQwCCgEKAiMEFQUMDQMKABEGRAcLAQYBAAAAAAAAABYMAQUHCwABCwMCDgEAACAZCgARCAYAAAAAAAAAAAcIDAMMAQwCCgEKAiMEFQUMDQMKABEHRAgLAQYBAAAAAAAAABYMAQUHCwABCwMCDwEAAA4OCgARBAQICwARAzgCDAEFDAsAATgDDAELAQIQAQAADw4KABEEBAgLABEEOAQMAQUMCwABOAUMAQsBAhEBAAAQDgoAEQQECAsAEQU4BgwBBQwLAAE4BwwBCwECEgEAABEOCgARBAQICwARBjgIDAEFDAsAATgJDAELAQITAQAAEg4KABEEBAgLABEHOAoMAQUMCwABOAsMAQsBAgAAAANoZXizCqEc6wsGAAAACAEABAMEFQQZAgUbJQdALAhsQAasAZ8GDMsHwgIABAEFAAMAAAAAAQAAAAACAQEAAQADBAEAAwEBCgIBAgUKCgIHCgIDAwoCAgcKCQAKCQAABAIDAwoCBQEBAQICBmFwcGVuZAZkZWNvZGULZGVjb2RlX2J5dGUGZW5jb2RlA2hleAZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAAKCgKCBoACAjAwAjAxAjAyAjAzAjA0AjA1AjA2AjA3AjA4AjA5AjBhAjBiAjBjAjBkAjBlAjBmAjEwAjExAjEyAjEzAjE0AjE1AjE2AjE3AjE4AjE5AjFhAjFiAjFjAjFkAjFlAjFmAjIwAjIxAjIyAjIzAjI0AjI1AjI2AjI3AjI4AjI5AjJhAjJiAjJjAjJkAjJlAjJmAjMwAjMxAjMyAjMzAjM0AjM1AjM2AjM3AjM4AjM5AjNhAjNiAjNjAjNkAjNlAjNmAjQwAjQxAjQyAjQzAjQ0AjQ1AjQ2AjQ3AjQ4AjQ5AjRhAjRiAjRjAjRkAjRlAjRmAjUwAjUxAjUyAjUzAjU0AjU1AjU2AjU3AjU4AjU5AjVhAjViAjVjAjVkAjVlAjVmAjYwAjYxAjYyAjYzAjY0AjY1AjY2AjY3AjY4AjY5AjZhAjZiAjZjAjZkAjZlAjZmAjcwAjcxAjcyAjczAjc0Ajc1Ajc2Ajc3Ajc4Ajc5AjdhAjdiAjdjAjdkAjdlAjdmAjgwAjgxAjgyAjgzAjg0Ajg1Ajg2Ajg3Ajg4Ajg5AjhhAjhiAjhjAjhkAjhlAjhmAjkwAjkxAjkyAjkzAjk0Ajk1Ajk2Ajk3Ajk4Ajk5AjlhAjliAjljAjlkAjllAjlmAmEwAmExAmEyAmEzAmE0AmE1AmE2AmE3AmE4AmE5AmFhAmFiAmFjAmFkAmFlAmFmAmIwAmIxAmIyAmIzAmI0AmI1AmI2AmI3AmI4AmI5AmJhAmJiAmJjAmJkAmJlAmJmAmMwAmMxAmMyAmMzAmM0AmM1AmM2AmM3AmM4AmM5AmNhAmNiAmNjAmNkAmNlAmNmAmQwAmQxAmQyAmQzAmQ0AmQ1AmQ2AmQ3AmQ4AmQ5AmRhAmRiAmRjAmRkAmRlAmRmAmUwAmUxAmUyAmUzAmU0AmU1AmU2AmU3AmU4AmU5AmVhAmViAmVjAmVkAmVlAmVmAmYwAmYxAmYyAmYzAmY0AmY1AmY2AmY3AmY4AmY5AmZhAmZiAmZjAmZkAmZlAmZmCgIBAAABAAACIQYAAAAAAAAAAAcDDgBBAQwEDAUMAwoDCgQjBB8FDA0FDAIHAgwBCwIOAQ4ACgNCARQ0QgAUOAALAwYBAAAAAAAAABYMAwUHCwUCAQEAAAUvBgAAAAAAAAAABwMOAEEBDAMMBAwCCgMGAgAAAAAAAAAZBgAAAAAAAAAAIQQOBRAHACcKAgoDIwQtBRUOAAoCQgEUEQIxEBgOAAoCBgEAAAAAAAAAFkIBFBECFgwBDQQLAUQBCwIGAgAAAAAAAAAWDAIFEAsEAgIAAAAGQDEwCgAlBAkKADE6IwwBBQsJDAELAQQSCwAxMBcMBQU+MUEKACUEGwoAMUcjDAIFHQkMAgsCBCYxCgsAFjFBFwwEBTwxYQoAJQQvCgAxZyMMAwUxCQwDCwMENAU2BwEnMQoLABYxYRcMBAsEDAULBQIAA3BhecMGoRzrCwYAAAAJAQAIAggKAxJNBF8OBW1+B+sBrQEImAMgBrgDCgzCA9YCAAkAAgAPABABAAwBAAEDAQIAAAgAAQEAAAwCAQEAAA4DAQEAAA0EAQEAAAMCAQEAAAUFAQEAAAYGAQEAAAcHAQEAAQQCEAEAAQUFAQEAAQwCCgEAAgoLAQEMAwsICQALCgoMAAwBDAgMCQwGDAILAAEJAAYIAQADBwsAAQkAAwcIAQMHCwABCQAKAwcIAQQHCwABCQADBQcIAQIHCwABCQALAAEJAAIHCwABCQAKCwABCQACCgsAAQkABQEGCAEBBQELAAEJAAIJAAUBCQACAwMBAwMDAwoLAAEJAAEKCwABCQADCwABCQADAwRDb2luCVR4Q29udGV4dARjb2luD2RpdmlkZV9hbmRfa2VlcA1kaXZpZGVfaW50b19uBGpvaW4Iam9pbl92ZWMVam9pbl92ZWNfYW5kX3RyYW5zZmVyBGtlZXADcGF5D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIFc3BsaXQSc3BsaXRfYW5kX3RyYW5zZmVyCXNwbGl0X3ZlYwh0cmFuc2Zlcgp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAAEAAAEFCwALAREMOAACAQEEAAEICwALAQoCOAELAi44AgICAQQADRsGAAAAAAAAAAAOAUEODAQMAwoDCgQjBBYFCgoADgEKA0IOFAoCOAMLAwYBAAAAAAAAABYMAwUFCwABCwIBAgMBBAABBwsACwELAzgBCwI4AAIEAQQADx8LAAsBCgI4BAwFBgAAAAAAAAAADgVBCgwEDAMKAwoEIwQaBQ8NBUUKCgIuEQw4AAsDBgEAAAAAAAAAFgwDBQoLAgELBUYKAAAAAAAAAAACBQEEAAEECwALATgFAgYBBAARGgYAAAAAAAAAAA4BQQoMBAwDCgMKBCMEFQUKDQFFCgwCCgALAjgFCwMGAQAAAAAAAAAWDAMFBQsAAQsBRgoAAAAAAAAAAAIHAQQAChIOAEEKBgAAAAAAAAAAJAQGBQgHACcNAEUKDAINAgsAOAYLAgsBOAACAANzdWnYBqEc6wsGAAAACgEADgIOMAM+PgR8DgWKAYUBB48CgQIIkARABtAEZgq2BQUMuwVtABYBEgAJAAoAFwAZABoABAIAAQMHAQAAAgAEAQABAgUEAQABAwEMAQABAwIMAQABAwYMAQABBQcCAAYIBwAAEAABAAAXAgMAAREDCQEAAgwQBwEAAg8REgEAAwsLDAECAxgPEAEABBMOAwEMBBQUAwEMBQ4FBwAFFQUGAAIIBQoHDQYKBAoDCggTAQcIBwELAgEIAAILBAEIAAUABAsFAQgACwMBCAALAgEIAAsGAQgAAQYIBwEFAQMBCAgBCwEBCQABCAAHCQACCgIKAgoCCwEBCAgHCAcCCwYBCQALBQEJAAELBQEIAAEJAAELBgEJAAELAwEJAAIHCwMBCQADAQsCAQkAAQsEAQgAAgkABQdCYWxhbmNlBENvaW4MQ29pbk1ldGFkYXRhBk9wdGlvbgNTVUkGU3VwcGx5C1RyZWFzdXJ5Q2FwCVR4Q29udGV4dANVcmwHYmFsYW5jZQRjb2luD2NyZWF0ZV9jdXJyZW5jeQ5kZXN0cm95X3N1cHBseQtkdW1teV9maWVsZAVlcG9jaA9pbmNyZWFzZV9zdXBwbHkDbmV3BG5vbmUGb3B0aW9uFHB1YmxpY19mcmVlemVfb2JqZWN0D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIDc3VpCHRyYW5zZmVyFHRyZWFzdXJ5X2ludG9fc3VwcGx5CnR4X2NvbnRleHQDdXJsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgAypo7AAAAAAMIAOQLVAIAAAADCAAA6IkEI8eKBSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCBANTVUkKAgQDU3VpCgIBAAACAQ0BAAAAAAQvCgAuEQoHBSEEBwULCwABBwEnCgAuEQkGAAAAAAAAAAAhBBIFFgsAAQcAJwkSADEJBwYHBwcIOAALADgBDAEMBAsBOAILBDgDDAINAgcEOAQMAwsCOAUBCwMCAQEEAAMECwALATgGAgADdXJsqgKhHOsLBgAAAAkBAAQCBAgDDBkFJRQHOU4IhwFACscBBgzNATIN/wECAAgBAgABBwABAAcAAAQAAQAABQIBAAADAwAAAAcEBQABBgIAAAEIAQEIAAEKAgEGCAACBwgACAEABlN0cmluZwNVcmwFYXNjaWkJaW5uZXJfdXJsCm5ld191bnNhZmUVbmV3X3Vuc2FmZV9mcm9tX2J5dGVzBnN0cmluZwZ1cGRhdGUDdXJsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQACAQgIAQABAAAFAwsAEgACAQEAAAUECwARBBIAAgIBAAAFBAsAEAAUAgMBAAAFBQsBCwAPABUCAAAABGNvaW6BEqEc6wsGAAAADQEAFgIWPgNUmwIE7wIkBZMD4wIH9gWiBQiYC0AG2AseCvYLNAuqDAgMsgz0BA2mEQ4OtBEOAA8BCwEtATIADAAZACwAOQA7ADwAQQABDAEAAQACDAEAAQAHDAEAAQADAwEAAQEFBwACBAcBAAADBQcABAAEAQABBAYEAQABBgkEAAgIAgAKCgcAADgAAQEAADoCAwEAADMEBQEAADQEBgEAAEMHAQEAAAwHCAEAAA0JCgEAABoLDAEAACMMDQEAADcODAEAAC8PEAEAACUREAEAADESDAEAABcSEwEAAEQUDAEAABYMEAEAABAVFgECACYXDAEAACgYDQEAAA4ZAQEAACcaEAEAAD8bEAEAAEAcEAEAAD0bEAEAAD4cEAEAABsdHgEAAB4dHwEAAB8dIAEAABwdHwEAAB0dIQEAATIqIAACMCIvAQADQiofAAQRIgMBAgQTLAEBAAQWDRABAAQiKw0BAAQlJQEBAAQxJA0BAAQ1BQEBAARDCAEBAAREEA0BAAUYIhABAwYUIxAABioUIwAHLi0QAQwJJCcoAQIKKyAuACciKCImIggiJSIJIgQiDCIpIiMiLiIqKSEiJCIiIhEiLQwfLgEGCwIBCQABAwELAgEJAAELCAEJAAEHCwIBCQABBgsIAQkAAQcLCAEJAAEGCwABCQABBgsHAQkAAQcLAAEJAAEHCwcBCQACCwcBCQAHCAoBCwABCQABCwcBCQADBwsHAQkAAwcICgIHCwcBCQALAAEJAAACBwsAAQkACwABCQADBwsAAQkAAwcICgEKCwABCQABBwgKBwkAAgoCCgIKAgsFAQgLBwgKAgsCAQkACwEBCQADBwsCAQkAAwcICgIHCwIBCQADAgcLAgEJAAsAAQkABAcLAgEJAAMFBwgKAwYLAgEJAAcLAQEJAAgGAwYLAgEJAAcLAQEJAAgEAQYLAQEJAAECAQgGAQgEAQsFAQgLAQkAAQgJAgcLBwEJAAMCBwsHAQkACwcBCQADAwMKCwABCQABBgkAAQEBCwMBCQABCgICBwsIAQkAAwIHCwgBCQALBwEJAAIJAAUBCAsBCwUBCQAHQmFsYW5jZQRDb2luDENvaW5NZXRhZGF0YQ9DdXJyZW5jeUNyZWF0ZWQGT3B0aW9uBlN0cmluZwZTdXBwbHkLVHJlYXN1cnlDYXAJVHhDb250ZXh0A1VJRANVcmwFYXNjaWkHYmFsYW5jZQtiYWxhbmNlX211dARidXJuBGNvaW4PY3JlYXRlX2N1cnJlbmN5DWNyZWF0ZV9zdXBwbHkIZGVjaW1hbHMPZGVjcmVhc2Vfc3VwcGx5BmRlbGV0ZQtkZXNjcmlwdGlvbgxkZXN0cm95X3plcm8NZGl2aWRlX2ludG9fbgRlbWl0BWV2ZW50DGZyb21fYmFsYW5jZQxnZXRfZGVjaW1hbHMPZ2V0X2Rlc2NyaXB0aW9uDGdldF9pY29uX3VybAhnZXRfbmFtZQpnZXRfc3ltYm9sCGljb25fdXJsAmlkD2luY3JlYXNlX3N1cHBseQxpbnRvX2JhbGFuY2UTaXNfb25lX3RpbWVfd2l0bmVzcwRqb2luBG1pbnQRbWludF9hbmRfdHJhbnNmZXIMbWludF9iYWxhbmNlBG5hbWUDbmV3Cm5ld191bnNhZmUGb2JqZWN0Bm9wdGlvbg9wdWJsaWNfdHJhbnNmZXIDcHV0BHNvbWUFc3BsaXQGc3RyaW5nBnN1cHBseQpzdXBwbHlfbXV0DHN1cHBseV92YWx1ZQZzeW1ib2wEdGFrZQx0b3RhbF9zdXBwbHkIdHJhbnNmZXIUdHJlYXN1cnlfaW50b19zdXBwbHkKdHhfY29udGV4dAV0eXBlcxJ1cGRhdGVfZGVzY3JpcHRpb24PdXBkYXRlX2ljb25fdXJsC3VwZGF0ZV9uYW1lDXVwZGF0ZV9zeW1ib2wDdXJsBHV0ZjgFdmFsdWUEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAAAAgIhCAkMCwcBCQABAgYhCAkSAikIBjYIBBUIBiALBQEICwICAiEICTgLCAEJAAMCARICAiIAIgMiASIAAQAAEAQLADcAOAACAQEAAAMGCwA6AAwBESsLAQICAQAAEAMLADcAAgMBAAAQAwsANgACBAEAABAECwA3ATgBAgUBAAAQAwsANwECBgEAABADCwA2AQIHAQAAEAULAREsCwA5AQIIAQAADQYLADoBDAERKwsBAgkBAAAQBwsCESwLAAsBOAI5AQIKAQAAEAYLAAsBOAM4BAECCwEEAA0KCwE6AQwCESsLADYBCwI4BAECDAEAABAGCwA2AQsBCwI4BQINAQAAJjsKAQYAAAAAAAAAACQEBQULCwABCwIBBwEnCgEKAC44BiUEEgUYCwABCwIBBwInQAwAAAAAAAAAAAwFBgAAAAAAAAAADAMKAC44BgoBGgwEKAoDCgEGAQAAAAAAAAAXIwQ1BSoNBQoACgQKAjgHRAwLAwYBAAAAAAAAABYMAwUiCwABCwIBCwUCDgEAABAFCwARLDgIOQECDwEAAA0HCwA6AQwBESsLATgJAhABAAAQHA4AOAoEBAUICwYBBwAnCgE5AjgLCgYRLAsAOAw5AAsGESwLAQsDESALAhEeCwQRIAsFOQMCEQEAABAICwIRLAsANgALATgNOQECEgEAABAFCwA2AAsBOA0CEwEEAA0JCwE6AQwCESsLADYACwI4DgIUAQQAEAcLAAsBCwM4DwsCOBACFQEEABAFCwILATYCFQIWAQQAEAULAgsBNgMVAhcBBAAQBQsCCwE2BBUCGAEEABAHCwIRLzgRCwE2BRUCGQEAABAECwA3BhQCGgEAABAECwA3AhQCGwEAABAECwA3AxQCHAEAABAECwA3BBQCHQEAABAECwA3BRQCAgEAAQECAQMBBAEFAQEAIgEiAiIDIgQiBSIGIgAEaGFzaHGhHOsLBgAAAAYBAAIDAgoFDAcHExoILSAMTQgAAQAAAAEAAAIAAQABBgoCAQoCCmJsYWtlMmIyNTYEaGFzaAlrZWNjYWsyNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgABAgABAQIAAARobWFjZKEc6wsGAAAABgEAAgMCBQUHCgcREwgkIAxEBAAAAAEAAQACBgoCBgoCAQoCBGhtYWMNaG1hY19zaGEzXzI1NgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAAEbWF0aKcFoRzrCwYAAAAGAQACAwIjBSUSBzc5CHAgDJAB+QMAAgADAAEAAAQAAQAAAAABAAAFAgEAAAYBAQAABwMDAAABAAEAAgMDAQMCAwIBBAMEBAQDDw8PBGRpZmYTZGl2aWRlX2FuZF9yb3VuZF91cARtYXRoA21heANtaW4DcG93BHNxcnQJc3FydF91MTI4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQAAAQsKAAoBJAQHCwAMAgUJCwEMAgsCAgEBAAABCwoACgEjBAcLAAwCBQkLAQwCCwICAgEAAAEPCgAKASQECQsACwEXDAIFDQsBCwAXDAILAgIDAQAAASEGAQAAAAAAAAAMAgoBMQEmBB8FBwoBMQIZMQAhBBYKAAsAGAwACwExAhoMAQUeCwIKABgMAgsBMQEXDAEFAgsCAgQBAAAEKzIAAAAAAAAAAAEAAAAAAAAADAEyAAAAAAAAAAAAAAAAAAAAAAwCCwA1DAMKATIAAAAAAAAAAAAAAAAAAAAAIgQoBQwKAwoCCgEWJgQfCwMKAgoBFhcMAwsCMQEwCgEWDAIFIwsCMQEwDAILATECMAwBBQcLAjQCBQEAAAUrSgAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAADAFKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAgsATQwDCgFKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiBCgFDAoDCgIKARYmBB8LAwoCCgEWFwwDCwIxATAKARYMAgUjCwIxATAMAgsBMQIwDAEFBwsCNQIGAQAAARMKAAoBGQYAAAAAAAAAACEECwsACwEaDAIFEQsACwEaBgEAAAAAAAAAFgwCCwICAAVjbG9ja6IDoRzrCwYAAAALAQAIAggMAxQfBDMCBTUeB1N6CM0BIAbtASwKmQIIDKECTw3wAgIAAwAHAAsADAAACAABAgQAAwECAAAKAAEAAAUCAwAABAQDAAEDAwYAAgkIAwEIAwgCBQAEBwEGCAABAwEGCAIAAwcIAAMGCAIBBQEIAQEIAAEJAAVDbG9jawlUeENvbnRleHQDVUlEBWNsb2NrGWNvbnNlbnN1c19jb21taXRfcHJvbG9ndWUGY3JlYXRlAmlkBm9iamVjdAZzZW5kZXIMc2hhcmVfb2JqZWN0DHRpbWVzdGFtcF9tcwh0cmFuc2Zlcgp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgYIAQoDAAEAAAMECwAQABQCAQAAAAMNCwARBQcBIQQGBQgHACcRAwYAAAAAAAAAABIAOAACAgAAAAMPCwIRBQcBIQQGBQoLAAEHACcLAQsADwAVAgABAAVlY3ZyZooBoRzrCwYAAAAHAQACAwIFBQcPBxYTCCkgBkkeDGcEAAAAAQABAAQGCgIGCgIGCgIGCgIBAQVlY3ZyZgxlY3ZyZl92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAABAgAABWV2ZW50V6Ec6wsGAAAABgEAAgMCBgUIBAcMCwgXIAw3BAABAAAAAQEDAQkAAARlbWl0BWV2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQIAAAVraW9za8odoRzrCwYAAAANAQAWAhZSA2jOAgS2AzgF7gPsAwfaB/MGCM0OQAaND3gKhRBRC9YQBAzaEJkMDfMcEg6FHQYALgE3ABMAGAAbABwAHgA2AEwATgBPAAYMAAAHDAAACwwBDAEAAQAAAAQHAAAIBwAACQcAAAUDAQwBAQoHAQAAAgAEAQABAwIMAQABBwMHAAcQBAAIDAIACQ0MAQABCQ4AAQABCg8CAAA0AAEAABcCAwAASgQFAABLBgUAADkHBQEMADIIBQEMAE0JCgEMADALBQEMADoMBQEMAD8NDgEMADEPEAEMAEMRDgEMAEYSBQEMAFQTAwAAIxQVAAApFBUAACcUFQAAKBQVAAAiFhUAAFEWFwAASRgFAABQGRcAADgaGwAAKxocAAA9Gh0AAD4WHgAAFB8gAQwAFQkhAQwAFgkiAQwARyMFAQwAQSQlAQwAQCQlAQwAQiQdAQwBGkMKAQABKkIVAQACLTsdAQACU0QdAQACVQUpAQADIS4vAQADJS8pAQADTUUvAQADUzodAQAEETEFAgcEBB9HFQEHBEQ1NwIHBARFNTYCBwQFETEFAgcMBRRHSgIHDAUVNUwCBwwFH0cVAQcFRDU3AgcMBh0KBQEDBxknBQAHJCAlAQgHNAAnAAdSLSUACTU8PQEACkgqGwAlKDUrJig1Ci4wKjIECi00MjAqNDM4BwosNCkoJygjKC0yOAoJCiIdIR0kKCgoMUYrSCtJLzAwMAEHCBACCAAIAQMIAAgBBwgQAQsKAQgNAwcIAAYIAQYIEAADBwgABggBBQMHCAAGCAEJAAQHCAAGCAEGCw4BCQAJAAMHCAAGCAEICwEJAAQHCAAGCAEICwMEBwgABggBCQADAwcIAAgLCwoBCA0CCQALDwEJAAUHCAAGCAEICwMHCBABCwIBCQADBwgACwIBCQALCgEIDQIHCAALAgEJAAQHCAAGCAELCAEDBwgQAgYIAAgLAQECBwgABggBAQcIDAMHCAAGCAEBAQcIAAEGCAABBQEOAQMBBwsJAQgNAwYIAAYIAQgLAQYJAAEHCQACCQAIAwMHCAAJAAgDAQYLAgEJAAEICwIIAQgAAQgMAQgNAQsJAQkAAQYIEAEIAAUIDAgLCAwOCwkBCA0BBggMAgsJAQkABwgQAQsKAQkAAggECQADBwgMCQAJAQIIBgEDCAsICwgLAggFAwIHCAwJAAELCAEJAQEJAQELBwEJAAIJAAMBBgsKAQkAAgcLCQEJAAsJAQkAAwgLAwgLAQsPAQkABggLCAwICwgLAwgMBQgMCAsICwMDAwgMCAsICwMDAwMBBgsIAQkAAQsIAQkAAQYLCQEJAAMHCwkBCQADBwgQAQgEAgYIDAkAAQgGAQgFAQYJAQIICwgLAQcJAQdCYWxhbmNlBkJvcnJvdwRDb2luAklEBEl0ZW0KSXRlbUxpc3RlZAVLaW9zaw1LaW9za093bmVyQ2FwB0xpc3RpbmcETG9jawZPcHRpb24LUHVyY2hhc2VDYXADU1VJDlRyYW5zZmVyUG9saWN5D1RyYW5zZmVyUmVxdWVzdAlUeENvbnRleHQDVUlEA2FkZBBhbGxvd19leHRlbnNpb25zB2JhbGFuY2UGYm9ycm93CmJvcnJvd19tdXQKYm9ycm93X3ZhbBJjbG9zZV9hbmRfd2l0aGRyYXcEY29pbgZkZWxldGUMZGVzdHJveV9zb21lDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQEZW1pdAVldmVudAdleGlzdHNfA2Zvcgxmcm9tX2JhbGFuY2UKaGFzX2FjY2VzcwhoYXNfaXRlbQJpZAxpbnRvX2JhbGFuY2UMaXNfZXhjbHVzaXZlCWlzX2xpc3RlZBVpc19saXN0ZWRfZXhjbHVzaXZlbHkJaXNfbG9ja2VkB2lzX3NvbWUKaXRlbV9jb3VudAdpdGVtX2lkBGpvaW4Fa2lvc2sIa2lvc2tfaWQEbGlzdBZsaXN0X3dpdGhfcHVyY2hhc2VfY2FwBGxvY2sJbWluX3ByaWNlA25ldwtuZXdfcmVxdWVzdAZvYmplY3QGb3B0aW9uBW93bmVyBXBsYWNlDnBsYWNlX2FuZF9saXN0BXByaWNlB3Byb2ZpdHMOcHJvZml0c19hbW91bnQLcHJvZml0c19tdXQIcHVyY2hhc2URcHVyY2hhc2VfY2FwX2l0ZW0ScHVyY2hhc2VfY2FwX2tpb3NrFnB1cmNoYXNlX2NhcF9taW5fcHJpY2URcHVyY2hhc2Vfd2l0aF9jYXAGcmVtb3ZlEHJlbW92ZV9pZl9leGlzdHMTcmV0dXJuX3B1cmNoYXNlX2NhcApyZXR1cm5fdmFsBnNlbmRlchRzZXRfYWxsb3dfZXh0ZW5zaW9ucwlzZXRfb3duZXIQc2V0X293bmVyX2N1c3RvbQNzdWkEdGFrZQ90cmFuc2Zlcl9wb2xpY3kKdHhfY29udGV4dAd1aWRfbXV0EHVpZF9tdXRfYXNfb3duZXIMdWlkX3RvX2lubmVyBXZhbHVlCHdpdGhkcmF3BHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMICgAAAAAAAAADCAsAAAAAAAAAAAIFJAgMPAsJAQgNOAUrDhIBAQICJAgMIAgLAgIEJAgMLwgLLAgLMwMDAgIvCAssCAsEAgEkCAsFAgIkCAsmAQYCASQICwcCAy4ICyQICzsDBwoCCgABAAAmEwoAETY4AAoALhE5SQAAAAAIEgAMAgsAETYOAjgBEgEMAQsCCwECAQEAACwmCwATAAEMBgEMBwwFCwETAQwEDAMOBRE3CwQhBBEFFQsCAQcAJwsGSQAAAAAhBBoFHgsCAQcDJwsDETQLBRE0CwcLAjgCAgIBAAAFFQoALjgBCwEQABQhBAkFDwsAAQsCAQcAJwsCETkLAA8BFQIDAQAABRIKAC44AQsBEAAUIQQJBQ0LAAEHACcLAgsADwEVAgQBAAAFHQoALjgBCwEQABQhBAkFDQsAAQcAJwoAEAIUSQEAAAAWCgAPAhULAA8DDgI4AxIECwI4BAIFAQAABQwKAA8DDgM4AxIGCDgFCwALAQsDOAYCBgEAADNICgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ8gBBYFGgsAAQcIJwoACgIMBC4LBBERIAQjBScLAAEHBCcKAAoCDAUuCwURDgQvBTMLAAEHCycKABACFEkBAAAAFwoADwIVCgAPAwoCCRIFOAcBCwAPAwsCEgQ4CAIHAQAAJSkKAC44AQsBEAAUIQQJBQ0LAAEHACcKAAoCDAQuCwQRESAEFgUaCwABBwQnCgAPAwoCCRIFCgM4CQsALjgBCwILAzkAOAoCCAEAACUNDgI4AwwECgAKAQsCOAYLAAsBCwQLAzgLAgkBAAA5MwoADwMKAQkSBTgMDAQKAA8DCgESBDgIDAMKABACFEkBAAAAFwoADwIVCgQOAjgNIQQbBR8LAAEHAScKAA8ECwI4DjgPAQoADwMKARIGOBABCwMLAQsECwAuOAE4EQIKAQAAPjwKAC44AQoBEAAUIQQJBRELAAELBAELAQEHACcKAAoCDAUuCwURECAEGgUiCwABCwQBCwEBBwYnCwQRNgwKCwAPAwoCCBIFCgM4CQsKDAYLAgwHCwEQABQMCAsDDAkLBgsICwcLCTkBAgsBAAA/MgsBOgEMBgwEDAUMAw4COA0MBwoHCwYmBA4FEgsAAQcBJwoALjgBCwUhBBkFHQsAAQcFJwoADwMKBAgSBTgMAQoADwMKBAkSBQsHOAkLAxE0CwALBAsCOBICDAEAAEAbCwE6AQEMAwwEDAIKAC44AQsEIQQNBRELAAEHBScLAA8DCwMIEgU4DAELAhE0Ag0BAABBMQoALjgBCwEQABQhBAkFDwsAAQsDAQcAJw4COBMEJQsCOBQMBgoGCgAQBDgVJQQcBSILAAELAwEHAicLBgwEBSkKABAEOBUMBAsEDAULAA8ECwULAzgWAg4BAAAFBgsAEAMLARIEOBcCDwEAAAUGCwAQAwsBEgY4GAIQAQAAFRIKABADCgEJEgU4GQQMCwABCAwCBRALAAsBEREMAgsCAhEBAAAFBwsAEAMLAQgSBTgZAhIBAAAFCAsALjgBCwEQABQhAhMBAAAFEAoALjgBCwEQABQhBAkFDQsAAQcAJwsADwMCFAEAAAUSCgAuOAELARAAFCEECQUNCwABBwAnCwILAA8FFQIVAQAABQwKABAFFAQFBQkLAAEHBycLAA8DAhYBAAAFBAsAEAEUAhcBAAAFBAsAEAIUAhgBAAAFBAsAEAQ4FQIZAQAABRAKAC44AQsBEAAUIQQJBQ0LAAEHACcLAA8EAhoBAAAFGwoAOAELARAAFCEECAUMCwABBwAnCgAKAhEOBBEFFQsAAQcLJwsAEAMLAhIEOBoCGwEAAEssCgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ4EFQUZCwABBwsnCgAKAgwELgsEERAgBCIFJgsAAQcJJwsADwMLAhIEOBsCHAEAAEsxCgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ4EFQUZCwABBwsnCgAKAgwELgsEERAgBCIFJgsAAQcJJwoADwMKAhIEOAgLAC44AQsCEgMCHQEAAEsgCwITAwwDDAQKAC44AQsEIQQLBQ8LAAEHBScOATgDCgMhBBUFGQsAAQcKJwsADwMLAxIECwE4BAIeAQAABQQLADcAFAIfAQAABQQLADcBFAIgAQAABQQLADcCFAIBAQACAAMAAAABAAQCAQICAgMGCgcKCAoABXRhYmxlggahHOsLBgAAAA0BAAgCCBADGHMEiwEKBZUBaAf9AacBCKQDIAbEAwoKzgMIC9YDAgzYA+UBDb0FBA7BBQQAEwAKABAAFAAADAIHAQQBAgIEAAMBAgAADwABAgcEAAMCAwIHBAAEBAUCBwQABQYHAgcEABEGCAIHBAAGBAkCBwQADgoLAgcEAA0KCQIHBAAIAQMCBwQACQEDAgcGAQMOAwIHBAEEDwUCBwQBBRAHAgcEAQsPCQIHBAEREAgCBwQCBwwDAAIPAAwACg0LDQwNDg0NDQEHCAIBCwACCQAJAQMHCwACCQAJAQkACQEAAgYLAAIJAAkBCQABBgkBAgcLAAIJAAkBCQABBwkBAQkBAQEBBgsAAgkACQEBAwEIAQIJAAkBAwcIAQkACQECBggBCQACBwgBCQACCAEDBVRhYmxlCVR4Q29udGV4dANVSUQDYWRkBmJvcnJvdwpib3Jyb3dfbXV0CGNvbnRhaW5zBmRlbGV0ZQ1kZXN0cm95X2VtcHR5BGRyb3ANZHluYW1pY19maWVsZBBleGlzdHNfd2l0aF90eXBlAmlkCGlzX2VtcHR5Bmxlbmd0aANuZXcGb2JqZWN0BnJlbW92ZQRzaXplBXRhYmxlCnR4X2NvbnRleHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAAAAgIMCAESAwANAAEAAAMFCwAREAYAAAAAAAAAADkAAgEBAAADDgoANgALAQsCOAAKADcBFAYBAAAAAAAAABYLADYBFQICAQAAAwULADcACwE4AQIDAQAAAwULADYACwE4AgIEAQAACA8KADYACwE4AwwCCgA3ARQGAQAAAAAAAAAXCwA2ARULAgIFAQAAAwULADcACwE4BAIGAQAAAwQLADcBFAIHAQAAAwYLADcBFAYAAAAAAAAAACECCAEAABEOCwA6AAwCDAELAgYAAAAAAAAAACEECQULBwAnCwERDwIJAQAAAwULADoAAREPAgAAAAEADQENAAV0eXBlc2ihHOsLBgAAAAYBAAIDAgYFCAYHDhoIKCAMSAQAAQAAAAEBAgEGCQABARNpc19vbmVfdGltZV93aXRuZXNzBXR5cGVzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQIAAAZib3Jyb3f+BKEc6wsGAAAADQEACAIIGAMgOwRbCgVlUwe4AZ4BCNYCQAaWAxQKqgMTC70DAgy/A30NvAQEDsAEBAAFAQ8ADgATAAMEAQwAAAAAAAECBwEAAAIBBwADBAIAAAwAAQEMAAUCAwEMABAEBQEMAAYBBgEMAQcJBgEAAQgLBgEAAQkPBQEAARIGCQEAAgsMDQEIAwoHCAAHBgUGCAYGBgQGAgkABwgEAQsAAQkAAQcLAAEJAAIJAAgBAwcLAAEJAAkACAEAAQkAAQcIBAEFAQsCAQkAAggDCQABBwsCAQkAAQYJAAEIAwIIAwUCBwsCAQkACQAGQm9ycm93AklEBk9wdGlvbghSZWZlcmVudAlUeENvbnRleHQGYm9ycm93B2Rlc3Ryb3kMZGVzdHJveV9zb21lB2V4dHJhY3QEZmlsbBRmcmVzaF9vYmplY3RfYWRkcmVzcwJpZANuZXcDb2JqBm9iamVjdAZvcHRpb24IcHV0X2JhY2sDcmVmBHNvbWUKdHhfY29udGV4dAV2YWx1ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAACAgsFFAsCAQkAAQICEQUNCAMABgABAAAFBgsBEQkLADgAOQACAQEAAAoOCgA2ADgBDAIOAjgCDAELAgsANwEUCwESAQICAQAADh4LAhMBDAMMBA4BOAILAyEECgUOCwABBwEnCgA3ARQLBCEEFQUZCwABBwAnCwA2AAsBOAMCAwEAAAkHCwA6AAwBAQsBOAQCAAEAAAAGAQYABm9iamVjdLcIoRzrCwYAAAAMAQAIAggMAxR+BJIBBgWYASMHuwH6Agi1BEAG9QRwCuUFCwzwBYICDfIHBA/2BwgAGAEEAAMAHgAABwAAAgQAAwECAAAVAAEAABQAAgAAEwEDAAASAgMAABsEBQAACAYFAAAfBwAAACIHAwAAIQcBAAAgBwIAABYIBQAACQUGAAAPCQMBCAAFCQABCAARCQEBCAAQCQIBCAAGCQcBCAAXAgUAAAoCBgAAGQIGAAEcCQEBAAIOAQIAAw0IAgADGgQCABQCEAoUAwEGCAABCgIBBQEIAAEGCAIBCAEAAQYIAQEHCAIBBgkAAQkAAklECVR4Q29udGV4dANVSUQHYWRkcmVzcwNiY3MJYm9ycm93X2lkCmJvcnJvd191aWQFYnl0ZXMFY2xvY2sGZGVsZXRlC2RlbGV0ZV9pbXBsDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQUZnJlc2hfb2JqZWN0X2FkZHJlc3MKZnJvbV9ieXRlcwJpZAppZF9hZGRyZXNzCGlkX2J5dGVzD2lkX2Zyb21fYWRkcmVzcw1pZF9mcm9tX2J5dGVzDWlkX3RvX2FkZHJlc3MLaWRfdG9fYnl0ZXMDbmV3EW5ld191aWRfZnJvbV9oYXNoBm9iamVjdA5yZWNvcmRfbmV3X3VpZAZzZW5kZXIQc3VpX3N5c3RlbV9zdGF0ZQh0b19ieXRlcwh0cmFuc2Zlcgp0eF9jb250ZXh0DHVpZF9hc19pbm5lcg51aWRfdG9fYWRkcmVzcwx1aWRfdG9fYnl0ZXMMdWlkX3RvX2lubmVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwgAAAAAAAAAAAUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEHBQECAQ8IAAABAAAGBAsAEAA4AAIBAQAABgQLABAAFAICAQAABgQLABEVEQMCAwEAAAYDCwASAAIEAAAABgwLABEXBwMhBAYFCAcCJwcAEgASAQIFAwAABgQHARIAEgECBgEAAAYDCwAQAQIHAQAABgQLABABFAIIAQAABgULABABEAA4AAIJAQAABgULABABEAAUAgoBAAAGBQsAERYSABIBAgsBAAAGBQsAEwETABESAgwBAAAGBQsAOAEQARQCDQEAAAYECwA4ARABAg4BAAAGBQsAOAEQATgCAg8BAAAGBgsAOAEQARAAFAIQAAIAEQMAAAYGCgAREwsAEgASAQISAAIAEwACAAAAAQAACAALAAwAHQAGcHJvdmVyXaEc6wsGAAAABAEAAgcCBwgJIAYpHgAABnByb3ZlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAAdhZGRyZXNzygOhHOsLBgAAAAkBAAoCCggDEj0ETwIFURQHZYEBCOYBQAamAjYM3AJFAAEBAgEDAQsACAEABwADAAcAAA8AAQAABwEAAAAGAgAAAA0AAgAADAADAAAOAAQAAAkFBgAACgUBAAELAgMAAg0HAgEAAwUDBAAEBAICAAkAAQUBDwEKAgEIAAEIAQABAwEGCQAGU3RyaW5nB2FkZHJlc3MFYXNjaWkDYmNzBmVuY29kZQpmcm9tX2FzY2lpCmZyb21fYnl0ZXMJZnJvbV91MjU2A2hleAZsZW5ndGgDbWF4BnN0cmluZw90b19hc2NpaV9zdHJpbmcIdG9fYnl0ZXMJdG9fc3RyaW5nB3RvX3UyNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwggAAAAAAAAAA8g//////////////////////////////////////////8DCAAAAAAAAAAAAAECAAEBAgACAQIAAwEAAAUDDgA4AAIEAQAABQULABEDEQsRCAIFAQAABQQLABEEEQoCBgEAAAUCBwACBwEAAAUCBwECAAdiYWxhbmNlyAehHOsLBgAAAA4BAAQCBBADFFMEZwIFaWMHzAHgAQisAyAGzANKCpYECgugBAQMpATbAg3/BgQOgwcED4cHAgADABAAAQQBAAEAAAQBAAEBAgIAABEAAQEAAA8CAQEAAAUDBAECAAoFBgEAAAYHAQEAABMIBgEAAAsJAQEAAA0KBgEAABILBgEAAAkGCAEAAAQMBgEAAAcNCAEAAAgEAQEAAQwODwAHAwEGCwEBCQABAwEGCwABCQABCQABCwABCQACBwsAAQkAAwELAQEJAAIHCwABCQALAQEJAAACBwsBAQkACwEBCQACBwsBAQkAAwEHCwEBCQACAwYIAgILAQEJAAYIAgEGCAIBBQdCYWxhbmNlBlN1cHBseQlUeENvbnRleHQHYmFsYW5jZRZjcmVhdGVfc3Rha2luZ19yZXdhcmRzDWNyZWF0ZV9zdXBwbHkPZGVjcmVhc2Vfc3VwcGx5F2Rlc3Ryb3lfc3RvcmFnZV9yZWJhdGVzDmRlc3Ryb3lfc3VwcGx5DGRlc3Ryb3lfemVybw9pbmNyZWFzZV9zdXBwbHkEam9pbgZzZW5kZXIFc3BsaXQDc3VpDHN1cHBseV92YWx1ZQp0eF9jb250ZXh0BXZhbHVlDHdpdGhkcmF3X2FsbAR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAREDAQIBEQMAAwEDAAEAAAgECwA3ABQCAQEAAAgECwA3ARQCAgEAAAgDBgAAAAAAAAAAOQACAwEAAAgYCgEG//////////8KADcBFBcjBAkFDQsAAQcBJwoANwEUCgEWCwA2ARULATkBAgQBAAABGAsBOgEMAgoANwEUCgImBAoFDgsAAQcBJwoANwEUCgIXCwA2ARULAgIFAQAACAMGAAAAAAAAAAA5AQIGAQAAAQ8LAToBDAIKADcAFAsCFgoANgAVCwA3ABQCBwEAAAgWCgA3ABQKASYEBwULCwABBwInCgA3ABQKARcLADYAFQsBOQECCAEAAAEICgA3ABQMAQsACwE4AAIJAQAACA0OADcAFAYAAAAAAAAAACEEBwUJBwAnCwA6AQECCgAAAAgLCwERDQcEIQQGBQgHAycLADkBAgsAAAAIDAsBEQ0HBCEEBgUIBwMnCwA6AQECDAMAAAgDCwA6AAIBAAAAAAMBAwAOAAdkaXNwbGF55gqhHOsLBgAAAA0BABACEC4DPoQBBMIBFgXYAcQBB5wD3wII+wVABrsGFArPBiYL9QYGDPsGoAMNmwoGDqEKBgAOAR8AEgAaABsAIAAhACQAAAwBCAEAAQMBCAEACAMBCAEBBAcAAwIHAAMGBAAEAwwABgUCAAcHBwIBAAAAABgAAQEIABkCAQEIAAwAAwEIACMEAwEIAAkFAwEIAAsGAwEIAA8FAwEIAB0HAwEIABcICQEIACUKCwEIABMKDAEIAA0NAQEIAAoFAwEIAhAOAwEDAxgNHAADIhUWAAQUCAkBAAUcEwMBDAYeERIABxEDHgIBAAcWHwMCAQAHHRobAgEACA4LDgAODA4RAQ0XFRkQDg0dExkUGQIGCAYHCAcBCwABCQAEBggGCggDCggDBwgHAAEHCwABCQADBwsAAQkACAMIAwMHCwABCQAKCAMKCAMCBwsAAQkACAMBBggGAQEBBgsAAQkAAQ0BBgsIAggDCAMBBwgHAQkAAwsAAQkAAwMBCAMBBggHAQUCCQAFAg0LCAIIAwgDAQYIBQEIBAELAgEJAAIDAwIIAwgDAgcLCAIJAAkBBgkAAgkACQEBCAUBCwEBCQABCwgCCQAJAQMHCwgCCQAJAQkACQEHRGlzcGxheQ5EaXNwbGF5Q3JlYXRlZAJJRAlQdWJsaXNoZXIGU3RyaW5nCVR4Q29udGV4dANVSUQGVmVjTWFwDlZlcnNpb25VcGRhdGVkA2FkZAxhZGRfaW50ZXJuYWwMYWRkX211bHRpcGxlD2NyZWF0ZV9hbmRfa2VlcA9jcmVhdGVfaW50ZXJuYWwHZGlzcGxheQRlZGl0BGVtaXQFZW1wdHkFZXZlbnQGZmllbGRzDGZyb21fcGFja2FnZQJpZAZpbnNlcnQNaXNfYXV0aG9yaXplZANuZXcPbmV3X3dpdGhfZmllbGRzBm9iamVjdAdwYWNrYWdlD3B1YmxpY190cmFuc2ZlcgZyZW1vdmUGc2VuZGVyBnN0cmluZwh0cmFuc2Zlcgp0eF9jb250ZXh0DHVpZF90b19pbm5lcg51cGRhdGVfdmVyc2lvbgd2ZWNfbWFwB3ZlcnNpb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAAAAgMVCAUTCwgCCAMIAyUNAQIBFQgEAgIDFQgEJQ0TCwgCCAMIAwIOAQ4ADgABAAADCwsAOAAEBAUICwEBBwAnCwE4AQIBAQAADysOAUEQDAYKBg4CQRAhBAkFDwsAAQsDAQcBJwYAAAAAAAAAAAwFCwALAzgCDAQKBQoGIwQpBRoNBA4BCgVCEBQOAgoFQhAUOAMLBQYBAAAAAAAAABYMBQUVCwQCAgEEAAMICwAKATgCCwEuERI4BAIDAQQAFBgKADcAFEgBABYKADYAFQoANwAUDAEKADcBFAwCCwA3AhEPCwELAjkAOAUCBAEEAAMFCwALAQsCOAMCBQEEABgmDgFBEAwECgQOAkEQIQQJBQ0LAAEHAScGAAAAAAAAAAAMAwoDCgQjBCMFFAoADgEKA0IQFA4CCgNCEBQ4AwsDBgEAAAAAAAAAFgwDBQ8LAAECBgEEAAMLCgA2AQ4BOAYBAQsACwELAjgDAgcBBAADBwsANgEOATgGAQECCAEAAAMDCwA4BwIJAQAAAwQLADcAFAIKAQAAAwMLADcBAgsAAAAcDAsAEQ4MAQ4BEQ85ATgICwE4CUgAADkCAgwAAAADBgsANgELAQsCOAoCAAIAAQAAAA4BDgIOAAdlZDI1NTE5aqEc6wsGAAAABgEAAgMCBQUHDAcTFwgqIAxKBAAAAAEAAQADBgoCBgoCBgoCAQEHZWQyNTUxOQ5lZDI1NTE5X3ZlcmlmeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAAHZ3JvdGgxNs0GoRzrCwYAAAAKAQACAgIQAxIyBURMB5AB7QII/QMgBp0EHgq7BCAM2wS0AQ2PBg4ACgAABwAAAQcAAAMHAAACBwAABQABAAAGAAEAABACAwAAEQMEAAAPBQYAAA4FBwAADAgDAAANCQMAABIKCwAAEwwLAAABCAAECgIKAgoCCgIBCAEBCgoCAQoCAQgCAQgDAgYIAAYKAgICBgoCBAYIAAYIAQYIAgYIAwEBBwIGCgIGCgIGCgIGCgIGCgIGCgIFQ3VydmUUUHJlcGFyZWRWZXJpZnlpbmdLZXkLUHJvb2ZQb2ludHMRUHVibGljUHJvb2ZJbnB1dHMWYWxwaGFfZzFfYmV0YV9nMl9ieXRlcwhibHMxMjM4MQVibjI1NAVieXRlcxVkZWx0YV9nMl9uZWdfcGNfYnl0ZXMVZ2FtbWFfZzJfbmVnX3BjX2J5dGVzB2dyb3RoMTYCaWQVcHJlcGFyZV92ZXJpZnlpbmdfa2V5HnByZXBhcmVfdmVyaWZ5aW5nX2tleV9pbnRlcm5hbBdwcm9vZl9wb2ludHNfZnJvbV9ieXRlcx5wdWJsaWNfcHJvb2ZfaW5wdXRzX2Zyb21fYnl0ZXMOcHZrX2Zyb21fYnl0ZXMMcHZrX3RvX2J5dGVzFHZlcmlmeV9ncm90aDE2X3Byb29mHXZlcmlmeV9ncm90aDE2X3Byb29mX2ludGVybmFsFXZrX2dhbW1hX2FiY19nMV9ieXRlcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAAIBCwIBAgQUCgIECgIJCgIICgICAgEHCgIDAgEHCgIAAQAAAAMxABIAAgEBAAAAAzEBEgACAgEAAAAGCwALAQsCCwMSAQIDAQAABBhABQAAAAAAAAAADAENAQ4AEAAURAUNAQ4AEAEURAUNAQ4AEAIURAUNAQ4AEAMURAULAQIEAQAAAAMLABICAgUBAAAAAwsAEgMCBgEAAAAGCwAQBBQLAREHAgcAAgAIAQAAABELABAEFAoBEAAKARABCgEQAgsBEAMLAhAFCwMQBhEJAgkAAgABAAEBAQIBAwAAAgADAAAHcGFja2FnZf8NoRzrCwYAAAALAQAOAg4kAzK3AQTpAQoF8wF2B+kC/gQI5wdABqcIXQqECTAMtAmBBA21DRQAJAEKATIAIQAwADEAMwABDAAABgwAAAgAAAAHAAABAgcAAgQHAAMABwADBQQABQMCAAAOAAEBAgAPAAIBAgAMAQIAABYDBAEAABUDBAEAACcDBQAAKAMFAAA0BgcAADYGCAAANQYJAAAuCgcAAC8KCQAAKQsHAAAqCwcAAC0KDAAAEQIJAAAJAgkAABMCCQAAIg0CAAAjDQIAAB4OAgAACw8QAAAQEQIAACsSAgACFwITAQACGBgZAAIZGBkAAxIXAgADGhUHAQgDGxsHAAMcHxsAAyAWFwAEJhwCAQwFLBobAAYdFQQBAiIUGBQAFCABHA4CCQAHCAgBCAAAAQYIAAEBAQYIBAEGCAEBCAYBAwECAQYIAgEGCAMBBgoCAQcIAQEIAQMHCAECCgIBCAICBwgBCAMCBwgBAgEIBQEJAAEGCQABBwgIAQgHAQYIBQEIBAEGCAgBBQIJAAUCAQgFAggGCAYBBggGAklECVB1Ymxpc2hlcgZTdHJpbmcJVHhDb250ZXh0CFR5cGVOYW1lA1VJRApVcGdyYWRlQ2FwDlVwZ3JhZGVSZWNlaXB0DVVwZ3JhZGVUaWNrZXQPYWRkaXRpdmVfcG9saWN5BWFzY2lpEWF1dGhvcml6ZV91cGdyYWRlDmJ1cm5fcHVibGlzaGVyA2NhcAVjbGFpbQ5jbGFpbV9hbmRfa2VlcA5jb21taXRfdXBncmFkZRFjb21wYXRpYmxlX3BvbGljeQZkZWxldGUPZGVwX29ubHlfcG9saWN5BmRpZ2VzdAtmcm9tX21vZHVsZQxmcm9tX3BhY2thZ2UDZ2V0C2dldF9hZGRyZXNzCmdldF9tb2R1bGUCaWQPaWRfZnJvbV9hZGRyZXNzDWlkX3RvX2FkZHJlc3MTaXNfb25lX3RpbWVfd2l0bmVzcw5tYWtlX2ltbXV0YWJsZQttb2R1bGVfbmFtZQNuZXcGb2JqZWN0Fm9ubHlfYWRkaXRpdmVfdXBncmFkZXMRb25seV9kZXBfdXBncmFkZXMHcGFja2FnZQZwb2xpY3kPcHVibGljX3RyYW5zZmVyEHB1Ymxpc2hlZF9tb2R1bGURcHVibGlzaGVkX3BhY2thZ2ULcmVjZWlwdF9jYXAPcmVjZWlwdF9wYWNrYWdlCHJlc3RyaWN0BnNlbmRlcg10aWNrZXRfZGlnZXN0DnRpY2tldF9wYWNrYWdlDXRpY2tldF9wb2xpY3kIdHJhbnNmZXIKdHhfY29udGV4dAl0eXBlX25hbWUFdHlwZXMPdXBncmFkZV9wYWNrYWdlDnVwZ3JhZGVfcG9saWN5B3ZlcnNpb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAACAQACAYACAcAFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDGggHJAgEHwgEAQIEGggHJAgGNgMlAgICBA0IBiQIBiUCFAoCAwICDQgGJAgGAAEAABMSDgA4AAQEBQgLAQEHACc4AQwCCwERHw4CERkOAhEaEgACAQEAAAIICwAKATgCCwEuESE4AwICAQAAAgYLABMAAQERGwIDAQAAEwk4AQwBDgERGQsAEAAUIQIEAQAAHRc4AQwCDgIRGQoAEAAUIQQRDgIRGgsAEAEUIQwBBRULAAEJDAELAQIFAQAAAgMLABABAgYBAAACAwsAEAACBwEAAAIECwAQAhQCCAEAAAIECwAQAxQCCQEAAAIECwAQBBQCCgEAAAIECwAQBRQCCwEAAAIECwAQBhQCDAEAAAIECwAQBxQCDQEAAAIECwAQCBQCDgEAAAIDCwAQCQIPAQAAAgIHBQIQAQAAAgIHBgIRAQAAAgIHBwISAQQAAgQLAAcGERcCEwEEAAIECwAHBxEXAhQBBAACBwsAEwEBAQERGwIVAQAAHikHCBEdDAMKABACFAoDIgQKBQ4LAAEHAicKAQoAEAQUJgQVBRkLAAEHAScKABACFAwECwMKAA8CFQsALjgECwQLAQsCEgICFgEAAB4nCwETAwwDDAIKAC44BAsCIQQLBQ8LAAEHBCcKABACER4HCCEEFgUaCwABBwMnCwMKAA8CFQoAEAMUBgEAAAAAAAAAFgsADwMVAhcAAAACEAoAEAQUCgElBAcFCwsAAQcBJwsBCwAPBBUCAAEAAgEBAQIBAwIBAgIDAAMBAgMAB3ZlY19tYXC4DaEc6wsGAAAADQEABgIGFgMcqAEExAEcBeAB/gEH3gOZAgj3BUAGtwYyCukGFQv+BgQMggfrBQ3tDAYO8wwGAB4BFQEfAAIHAgEAAAAAAAcCAQAAAAEBBwEAAAAHAAECAQAADgIAAgEAABcDBAIBAAAWBQQCAQAADQMGAgEAAAgHCAIBAAAcBwkCAQEAAwcKAgEAABoLDAIBAAAQCwoCAQAABQEAAgEAAA8BDQIBAAATCw4CAQAADAcPAgEAAAsHDAIBAAAJEBECAQAAChITAgEAABgSBAIBAAEGGxgBAAERHAoBAAEUABsBAAEbGBsBAAIQGQoBAAIXFxgBAAIZHwABAAcEDgQXFBYUBQQVGhQaDQQTDAgEGBQVDBQMEgwAAQsAAgkACQEDBwsAAgkACQEJAAkBAgcLAAIJAAkBBgkAAgkACQEBBwsAAgkACQEBBwkBAgYLAAIJAAkBBgkAAQYJAQELAgEJAQEBAQYLAAIJAAkBAQMCCgkACgkBAQoJAAELAgEDAgYLAAIJAAkBAwIGCQAGCQECBwsAAgkACQEDAgYJAAcJAQELAQIJAAkBAQYJAAIGCQADAgcKCQADAQkAAQYKCQABCQEBCwIBCQABBgsCAQkAAQoLAQIJAAkBBwoLAQIJAAkBAwkACgkAAwkBCgkBAQcKCQAEBgsBAgkACQEDCgkAAwIDAwEGCwECCQAJAQEHCwECCQAJAQVFbnRyeQZPcHRpb24GVmVjTWFwCGNvbnRhaW5zCGNvbnRlbnRzDWRlc3Ryb3lfZW1wdHkMZGVzdHJveV9zb21lBWVtcHR5A2dldBBnZXRfZW50cnlfYnlfaWR4FGdldF9lbnRyeV9ieV9pZHhfbXV0B2dldF9pZHgLZ2V0X2lkeF9vcHQHZ2V0X211dAZpbnNlcnQQaW50b19rZXlzX3ZhbHVlcwhpc19lbXB0eQdpc19zb21lA2tleQRrZXlzBG5vbmUGb3B0aW9uA3BvcAZyZW1vdmUTcmVtb3ZlX2VudHJ5X2J5X2lkeAdyZXZlcnNlBHNpemUEc29tZQd0cnlfZ2V0BXZhbHVlB3ZlY19tYXAGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAAIBBAoLAQIJAAkBAQICEgkAHQkBAAQBBAABAAAAA0AUAAAAAAAAAAA5AAIBAQAAFRQKAA4BDAMuCwM4ACAECQUNCwABBwAnCwA2AAsBCwI5AUQUAgIBAAAWDQoACwEMAi4LAjgBDAMLADYACwM4AjoBAgMBAAAADwoANwA4AyAEBgUKCwABBwQnCwA2AEUUOgECBAEAABYNCgALAQwCLgsCOAEMAwsANgALA0MUNgECBQEAAAwKCgALATgBDAILADcACwJCFDcBAgYBAAAJEwoACgE4AAQLCwALATgEFDgFDAIFEQsAAQsBATgGDAILAgIHAQAADwcLAAsBOAcMAg4COAgCCAEAAAAECwA3AEEUAgkBAAAABQsAOAkGAAAAAAAAAAAhAgoBAAAdDAsAOgAMAQ4BOAMEBwUJBwInCwFGFAAAAAAAAAAAAgsBAAAeKAsAOgAMAQ0BOAoGAAAAAAAAAAAMAg4BQRQMBUAYAAAAAAAAAAAMBEAaAAAAAAAAAAAMBwoCCgUjBCMFEw0BRRQ6AQwGDAMNBAsDRBgNBwsGRBoLAgYBAAAAAAAAABYMAgUOCwFGFAAAAAAAAAAACwQLBwIMAQAAICAGAAAAAAAAAAAMAgoANwBBFAwEQBgAAAAAAAAAAAwDCgIKBCMEHAUNCgA3AAoCQhQMAQ0DCwE3AhREGAsCBgEAAAAAAAAAFgwCBQgLAAELAwINAQAAISQGAAAAAAAAAAAMAgoAOAkMAwoCCgMjBB4FCgoANwAKAkIUNwIKASEEGQsAAQsBAQsCOAsCCwIGAQAAAAAAAAAWDAIFBQsAAQsBATgMAg4BAAAPDQsACwE4BwwCDgI4CAQIBQoHAScLAjgNAg8BAAAiFAoBCgA4CSMEBgUKCwABBwMnCwA3AAsBQhQMAgoCNwILAjcBAhABAAAjFQoBCgAuOAkjBAcFCwsAAQcDJwsANgALAUMUDAIKAjcCCwI2AQIRAQAAABEKAQoALjgJIwQHBQsLAAEHAycLADYACwE4AjoBAgAAAQEBAAAEAQQCBAAHdmVjX3NldK0GoRzrCwYAAAANAQAGAgYMAxJgBHIUBYYBWgfgAZ8BCP8CQAa/AxQK0wMHC9oDAgzcA5ECDe0FAg7vBQIAEgENARMAAQcBAwABAAcBAAAABQABAQMADwIBAQMACAMAAQMADgQAAQMAAgUGAQMAEAcIAQMACgcGAQMACQEJAQMABwUKAQMABgUIAQMBBBACAQABCw4GAQABDAAQAQABEQIQAQACDg0CAQACDwIJAQAPAgQCCQIOAggCCwgFAg0IDAgKCAABCwABCQABCQACBwsAAQkACQACBwsAAQkABgkAAgYLAAEJAAYJAAEBAQYLAAEJAAEDAQoJAAELAQEDAQYJAAIGCQADAgcKCQADAQYLAQEJAAIDAwELAQEJAAZPcHRpb24GVmVjU2V0CGNvbnRhaW5zCGNvbnRlbnRzDGRlc3Ryb3lfc29tZQVlbXB0eQdnZXRfaWR4C2dldF9pZHhfb3B0Bmluc2VydAlpbnRvX2tleXMIaXNfZW1wdHkHaXNfc29tZQRub25lBm9wdGlvbgZyZW1vdmUJc2luZ2xldG9uBHNpemUEc29tZQd2ZWNfc2V0BnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAACAQMKCQAAAgABAAAAA0ACAAAAAAAAAAA5AAIBAQAAAAQLADgAOQACAgEAAAsSCgAOAQwCLgsCOAEgBAkFDQsAAQcAJwsANgALAUQCAgMBAAAMDQoACwEMAi4LAjgCDAMLADYACwM4AwECBAEAAAoHCwALATgEDAIOAjgFAgUBAAAABAsANwBBAgIGAQAAAAULADgGBgAAAAAAAAAAIQIHAQAAAAMLADoAAggAAAAPIwYAAAAAAAAAAAwCCgA4BgwDCgIKAyMEHQUKCgA3AAoCQgIKASEEGAsAAQsBAQsCOAcCCwIGAQAAAAAAAAAWDAIFBQsAAQsBATgIAgkAAAAKDQsACwE4BAwCDgI4BQQIBQoHAScLAjgJAgAAAAIACGJsczEyMzgxlAGhHOsLBgAAAAYBAAIDAgoFDAwHGDgIUCAMcAgAAAACAAEAAAEAAQADBgoCBgoCBgoCAQEIYmxzMTIzODEWYmxzMTIzODFfbWluX3BrX3ZlcmlmeRdibHMxMjM4MV9taW5fc2lnX3ZlcmlmeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAEBAgAACGVjZHNhX2sx1AGhHOsLBgAAAAcBAAIDAg8FERwHLUAIbSAGjQEaDKcBDAABAAIAAQAAAAIBAAADAwQAAwYKAgYKAgIBCgIBBgoCBAYKAgYKAgYKAgIBARFkZWNvbXByZXNzX3B1YmtleQhlY2RzYV9rMRNzZWNwMjU2azFfZWNyZWNvdmVyEHNlY3AyNTZrMV92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAgEAAgEBAAECAAEBAgACAQIAAAhlY2RzYV9yMbQBoRzrCwYAAAAHAQACAwIKBQwYByQuCFIgBnIaDIwBCAAAAAEAAQAAAgIDAAMGCgIGCgICAQoCBAYKAgYKAgYKAgIBAQhlY2RzYV9yMRNzZWNwMjU2cjFfZWNyZWNvdmVyEHNlY3AyNTZyMV92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAgEAAgEBAAECAAEBAgAACHRyYW5zZmVy+AKhHOsLBgAAAAgBAAIDAjYEOAYFPggHRpABCNYBIAb2AQoMgAJSAAcABwABAQgABAABAQwAAAIBAQgAAgIBAQwABQIBAQgAAwIBAQwAAQIBAQgABgIBAQgACAABAQgIAgYCBwICCQAFAAEJAA1mcmVlemVfb2JqZWN0EmZyZWV6ZV9vYmplY3RfaW1wbBRwdWJsaWNfZnJlZXplX29iamVjdBNwdWJsaWNfc2hhcmVfb2JqZWN0D3B1YmxpY190cmFuc2ZlcgxzaGFyZV9vYmplY3QRc2hhcmVfb2JqZWN0X2ltcGwIdHJhbnNmZXINdHJhbnNmZXJfaW1wbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAABAAABBAsACwE4AAIBAQAAAQQLAAsBOAACAgEAAAEDCwA4AQIDAQAAAQMLADgBAgQBAAABAwsAOAICBQEAAAEDCwA4AgIGAwIABwMCAAgDAgAACXRhYmxlX3ZlY7IGoRzrCwYAAAANAQAGAgYSAxhnBH8UBZMBigEHnQKfAQi8AyAG3AMUCvADCgv6AwIM/AP1AQ3xBQIO8wUCABEAEAASAAEEAQQBAQAMAgcBBAECAgIAAAgAAQEEAA8CAQEEAAoDBAEEAAkDBQEEAAQGBwEEAA0ICQEEAAUKCwEEAAwMDQEEAAcBCQEEAQMTCQIHBAEEERICBwQBBRQVAgcEAQcPCQIHBAEKEAQCBwQBCwAPAgcEAQ4UFgIHBA4OAA0FDQ0OAg0KDgkOCw4PDgwOAQcIAgELAAEJAAIJAAcIAgEGCwABCQABAwEBAgYLAAEJAAMBBgkAAgcLAAEJAAkAAAIHCwABCQADAQcJAAEHCwABCQABCQACAwkAAQsBAgkACQEBBgsBAgkACQECBgsBAgkACQEJAAEGCQEDBwsBAgkACQEJAAkBAgcLAQIJAAkBCQABBwkBAQkBBVRhYmxlCFRhYmxlVmVjCVR4Q29udGV4dANhZGQGYm9ycm93CmJvcnJvd19tdXQIY29udGVudHMNZGVzdHJveV9lbXB0eQVlbXB0eQhpc19lbXB0eQZsZW5ndGgDbmV3CHBvcF9iYWNrCXB1c2hfYmFjawZyZW1vdmUJc2luZ2xldG9uBXRhYmxlCXRhYmxlX3ZlYwp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAACAQYLAQIDCQAADQABAAAJBAsAOAA5AAIBAQAAAQgLATgBDAINAgsAOAILAgICAQAACQQLADcAOAMCAwEAAAkFCwA4BAYAAAAAAAAAACECBAEAAAkPCgA4BAoBJAQGBQoLAAEHACcLADcACwE4BQIFAQAABAoKAC44BAwCCwA2AAsCCwE4BgIGAQAACRAKAC44BAoBJAQHBQsLAAEHACcLADYACwE4BwIHAQAABBQKAC44BAwBCgEGAAAAAAAAAAAkBAkFDQsAAQcAJwsANgALAQYBAAAAAAAAABc4CAIIAQAACQwOADgEBgAAAAAAAAAAIQQGBQgHAScLADoAOAkCAAAADQAJdmVyc2lvbmVk/gWhHOsLBgAAAAsBAAgCCBQDHFUEcQoFe2EH3AHsAQjIAyAG6AMKCvIDEAyCBMUBDccFBAAXAAsAEAAUAAQMAAADAAACAAcAAgIEAAMBAgAACAABAQQAFgIDAAANAgQBBAAOBQYBBAATBQcBBAAVCAkBBAAKAQoBBAEFDgkCBwQBBg8QAgcEAQcREgIHBAESERMCBwQCCQwJAAIMBBQBCAIPCwwABw0IDQkNCg0MAQMDCQAHCAQBCAABBggAAQMBBgkAAQcIAAEHCQACCQAIAQQHCAADCQAIAQABCQABBwgEAQgDAgMJAAMHCAMJAAkBAgYIAwkAAQYJAQIHCAMJAAEHCQEBCQEBCAIDCAMJAAMCSUQJVHhDb250ZXh0A1VJRBBWZXJzaW9uQ2hhbmdlQ2FwCVZlcnNpb25lZANhZGQGYm9ycm93CmJvcnJvd19tdXQGY3JlYXRlBmRlbGV0ZQdkZXN0cm95DWR5bmFtaWNfZmllbGQCaWQKbG9hZF92YWx1ZQ5sb2FkX3ZhbHVlX211dANuZXcGb2JqZWN0C29sZF92ZXJzaW9uBnJlbW92ZRhyZW1vdmVfdmFsdWVfZm9yX3VwZ3JhZGUKdHhfY29udGV4dAd1cGdyYWRlB3ZlcnNpb24JdmVyc2lvbmVkDHZlcnNpb25lZF9pZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAACAgwIAxYDAQICGAgCEQMAAQAAAQwLAhENCgASAAwDDQMPAAsACwE4AAsDAgEBAAAJBAsAEAEUAgIBAAAJBwoAEAALABABFDgBAgMBAAAJBwoADwALABABFDgCAgQBAAAJDgoADwAKABABFDgDCgAuOAQLABABFBIBAgUBAAADIAsDEwEMBAoALjgEIQQJBQ0LAAEHACcLBAoBIwQSBRYLAAEHACcKAA8ACgELAjgACwELAA8BFQIGAQAAFQwLABMADAMMAQ0BCwM4AwwCCwERCwsCAgAAAAEACm9iamVjdF9iYWfpBqEc6wsGAAAACwEACgIKFgMgfAScAQ4FqgFYB4IC5wEI6QNABqkECgqzBAgMuwT1AQ2wBgQAFAEVAAwAEwAYAAEMAAECBwEAAAMABwADBAQABAMCAAASAAEAAAUCAwIHDAAGBAUCBwwABwYHAgcMABYGCAIHDAAIBAkBBwAJBAkCBwwAEQoLAAAQCgkAAAsBAwAAGQQMAQcCBQ8DAgcMAgYQBQIHDAIHEQcCBwwCDRAJAQcCDhAJAgcMAg8QDAEHAhYRCAIHDAMKDQMAAxIADQALDgwODQ4RDg4SDw4QEgEHCAQBCAADBwgACQAJAQACBggACQABBgkBAgcIAAkAAQcJAQEJAQEBAQYIAAEDAQsBAQgCAQgDAgkACQEDBwgDCQAJAQIGCAMJAAIHCAMJAAEJAAIIAwMCSUQJT2JqZWN0QmFnBk9wdGlvbglUeENvbnRleHQDVUlEA2FkZAZib3Jyb3cKYm9ycm93X211dAhjb250YWlucxJjb250YWluc193aXRoX3R5cGUGZGVsZXRlDWRlc3Ryb3lfZW1wdHkUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlAmlkCGlzX2VtcHR5Bmxlbmd0aANuZXcGb2JqZWN0Cm9iamVjdF9iYWcGb3B0aW9uBnJlbW92ZQRzaXplCnR4X2NvbnRleHQIdmFsdWVfaWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAACAg8IAxcDAAEAAAMFCwAREwYAAAAAAAAAABIAAgEBAAADDgoADwALAQsCOAAKABABFAYBAAAAAAAAABYLAA8BFQICAQAAAwULABAACwE4AQIDAQAAAwULAA8ACwE4AgIEAQAACA8KAA8ACwE4AwwCCgAQARQGAQAAAAAAAAAXCwAPARULAgIFAQAAAwULABAACwE4BAIGAQAAAwULABAACwE4BQIHAQAAAwQLABABFAIIAQAAAwYLABABFAYAAAAAAAAAACECCQEAABMOCwATAAwCDAELAgYAAAAAAAAAACEECQULBwAnCwEREgIKAQAAAwULABAACwE4BgIAAAABAAp0eF9jb250ZXh0+QKhHOsLBgAAAAoBAAICAgQDBh4FJBQHOGgIoAEgBsABFArUAQ4M4gFgDcICCgAHAAACAAAGAAEAAAIAAgAAAwACAAAEAwEAAAUAAgAAAQQBAAEGCAABBQEDAQcIAAIKAgMAAgUDCVR4Q29udGV4dAlkZXJpdmVfaWQFZXBvY2gSZXBvY2hfdGltZXN0YW1wX21zFGZyZXNoX29iamVjdF9hZGRyZXNzC2lkc19jcmVhdGVkBnNlbmRlcgp0eF9jb250ZXh0B3R4X2hhc2gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIIAAAAAAAAAADCAAAAAAAAAAAAAIFBgUICgICAwMDBQMAAQAABQQLABAAFAIBAQAABQQLABABFAICAQAABQQLABACFAIDAQAABhIKABADFAwCCgAQBBQKAhEFDAELAgYBAAAAAAAAABYLAA8DFQsBAgQAAAAFBAsAEAMUAgUAAgAAAAACAAMABAABAAxsaW5rZWRfdGFibGWRDaEc6wsGAAAADQEACgIKHgMo1AEE/AEcBZgCvAEH1APNAgihBkAG4QYUCvUGJgubBwQMnweXBQ22DA4OxAwOABgBHQAOABwAKAAADAIHAAQBAAEEAgcABAABAgcBAAADBAQABAMCAAAZAAECBwQAEQIDAgcEAAYCAwIHBAAiBAUCBwQAIQQFAgcEAAcGBwIHBAAICAkCBwQAIAYDAgcEABoGAwIHBAAjCAoCBwQAHwsMAgcEAB4LDAIHBAAJBg0CBwQAFwIOAgcEABQCDQIHBAALAQUCBwQADQEFAgcGAQcDGQEAAQwREAEAARATBQEAARUDDQEAARYDDQEAARsFEQEAASUQEQEAASYTEQEAAgUWBQIHBAIHFwcCBwQCCBUJAgcEAg8XDQIHBAIjFQoCBwQDCg8FAAMZAA8AFhAYEBQQExAVEBIQFxAbFBkUGhQdFBEQCQwcFAEHCAQBCwACCQAJAQEGCwACCQAJAQEGCwIBCQADBwsAAgkACQEJAAkBAAIGCwACCQAJAQkAAQYJAQIHCwACCQAJAQkAAQcJAQEJAQEHCwACCQAJAQIJAAkBAQEBAwEIAwEJAAELAgEJAAULAgEJAAsCAQkACwIBCQAJAAsCAQkAAgcLAgEJAAkAAgkACwECCQAJAQIHCAMJAAMHCAMJAAkBAgYIAwkAAwsCAQkACwIBCQAJAQEGCQACCAMDC0xpbmtlZFRhYmxlBE5vZGUGT3B0aW9uCVR4Q29udGV4dANVSUQDYWRkBGJhY2sGYm9ycm93CmJvcnJvd19tdXQIY29udGFpbnMGZGVsZXRlDWRlc3Ryb3lfZW1wdHkMZGVzdHJveV9zb21lBGRyb3ANZHluYW1pY19maWVsZBBleGlzdHNfd2l0aF90eXBlBGZpbGwFZnJvbnQEaGVhZAJpZAhpc19lbXB0eQdpc19ub25lB2lzX3NvbWUGbGVuZ3RoDGxpbmtlZF90YWJsZQNuZXcEbmV4dARub25lBm9iamVjdAZvcHRpb24IcG9wX2JhY2sJcG9wX2Zyb250BHByZXYJcHVzaF9iYWNrCnB1c2hfZnJvbnQGcmVtb3ZlBHNpemUEc29tZQxzd2FwX29yX2ZpbGwEdGFpbAp0eF9jb250ZXh0BXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAAIEEwgDJAMSCwIBCQAnCwIBCQABAgMgCwIBCQAaCwIBCQApCQEADAEMAAEAAAUHCwARHwYAAAAAAAAAADgAOAA5AAIBAQAABQMLADcAAgIBAAAFAwsANwECAwEAABI2CgA2AAoBOAEMBQoANwE4AgQNCgA2AQoBOAM4AAwHDgU4BAQhCwU4BQwGCgE4BgoANgIKBjgHNgMVCwY4BgwDBSM4AAwDCwMMBAoANgILAQsHCwQLAjkBOAgKADcEFAYBAAAAAAAAABYLADYEFQIEAQAAEjYKADcAOAIECAoANgAKATgDCgA2AQoBOAEMBQ4FOAQEHwsFOAUMBgoBOAYKADYCCgY4BzYFFQsGOAYMAwUhOAAMAwsDDAc4AAwECgA2AgsBCwcLBAsCOQE4CAoANwQUBgEAAAAAAAAAFgsANgQVAgUBAAAFBgsANwILATgJNwYCBgEAAAUGCwA2AgsBOAc2BgIHAQAABQYLADcCCwE4CTcDAggBAAAFBgsANwILATgJNwUCCQEAABhBCgA2AgoBOAo6AQwEDAIMAwoANwQUBgEAAAAAAAAAFwoANgQVDgM4BAQcCgIKADYCDgM4CxQ4BzYFFQ4COAQEKAoDCgA2Ag4COAsUOAc2AxUKADcAOAsOASEEMgsCCgA2ABUKADcBOAsOASEEPQsDCwA2ARUFPwsAAQsEAgoBAAAQEwoANwA4BAQFBQkLAAEHAScKADcAOAsUDAEKAQsACwE4DAILAQAAEBMKADcBOAQEBQUJCwABBwEnCgA3ATgLFAwBCgELAAsBOAwCDAEAAAUFCwA3AgsBOA0CDQEAAAUECwA3BBQCDgEAAAUGCwA3BBQGAAAAAAAAAAAhAg8BAAAaEAsAOgABAQwCDAELAgYAAAAAAAAAACEECwUNBwAnCwERHgIQAQAABQcLADoAAQEBER4CAAIAAwAAAQAAAQEBAQIADAEMAgwDDAQMBQwGDAAMb2JqZWN0X3RhYmxl3wahHOsLBgAAAA0BAAoCChoDJHgEnAEMBagBcQeZAscBCOADQAagBAoKqgQIC7IEAgy0BOYBDZoGBA6eBgQAEgETAAsAEQAWAAEMAgcBDAEBAgcBAAADAAcAAwQEAAQDAgAAEAABAgcMAAUCAwIHDAAGBAUCBwwABwYHAgcMABQGCAIHDAAIBAkCBwwADwoLAgcMAA4KCQIHDAAKAQMCBwwAFwQMAgcMAgUPAwIHDAIGEAUCBwwCBxEHAgcMAgwQCQEHAg0QDAEHAhQRCAIHDAMJDQMAAxAADQAKDgsODA4PDg0SDhIBBwgEAQsAAgkACQEDBwsAAgkACQEJAAkBAAIGCwACCQAJAQkAAQYJAQIHCwACCQAJAQkAAQcJAQEJAQEBAQYLAAIJAAkBAQMBCwEBCAIBCAMCCQAJAQMHCAMJAAkBAgYIAwkAAgcIAwkAAQkAAggDAwJJRAtPYmplY3RUYWJsZQZPcHRpb24JVHhDb250ZXh0A1VJRANhZGQGYm9ycm93CmJvcnJvd19tdXQIY29udGFpbnMGZGVsZXRlDWRlc3Ryb3lfZW1wdHkUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXwJpZAhpc19lbXB0eQZsZW5ndGgDbmV3Bm9iamVjdAxvYmplY3RfdGFibGUGb3B0aW9uBnJlbW92ZQRzaXplCnR4X2NvbnRleHQIdmFsdWVfaWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAACAg0IAxUDAA4AAQAAAwULABERBgAAAAAAAAAAOQACAQEAAAMOCgA2AAsBCwI4AAoANwEUBgEAAAAAAAAAFgsANgEVAgIBAAADBQsANwALATgBAgMBAAADBQsANgALATgCAgQBAAAIDwoANgALATgDDAIKADcBFAYBAAAAAAAAABcLADYBFQsCAgUBAAADBQsANwALATgEAgYBAAADBAsANwEUAgcBAAADBgsANwEUBgAAAAAAAAAAIQIIAQAAEw4LADoADAIMAQsCBgAAAAAAAAAAIQQJBQsHACcLAREQAgkBAAADBQsANwALATgFAgAAAAEADgEOAA1keW5hbWljX2ZpZWxklgqhHOsLBgAAAA4BAAYCBhYDHIUBBKEBGAW5AagBB+ECgQMI4gVABqIGKArKBgwL1gYCDNgG6wINwwkGDskJCA/RCQIACwEaABkAAAgCBwAEAAECBwEAAAIBBwACAwQAAAQAAQIHBAAGAgMCBwQACQQFAgcEABsEBgIHBAANAgcBBwAdBAgCBwQADgIHAgcEAA8CCQEHABAECgEHABMLDAEHAAULAQEIAAcJDQEIAAgKDgEIABwPEAEIABEPBwAAEg8HAQgBGAEYAQABHhAYAQACChMBAAIVHAwAAhcMEwACHxIMAAkQChULFQwVDRUEEAMUEQYQBg8VCxoMGgMHCAMJAAkBAAIGCAMJAAEGCQECBwgDCQABBwkBAQkBAQEBCwEBCQECBggDBQIHCAMFAgUJAAEFAQYJAAEHCQACBQUBCQADCwACCQAJAQUFAQYIAwEIAwIJAAkBAQsAAgkACQEDBQUJAQIJAAsBAQkBAQsBAQkABAYLAAIJAAgCBQYIAwYIAgELAAIJAAgCAgkACAIBBggCBAcLAAIJAAgCBQcIAwcIAgVGaWVsZAJJRAZPcHRpb24DVUlEA2FkZBBhZGRfY2hpbGRfb2JqZWN0BmJvcnJvdxNib3Jyb3dfY2hpbGRfb2JqZWN0F2JvcnJvd19jaGlsZF9vYmplY3RfbXV0CmJvcnJvd19tdXQGZGVsZXRlDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlCmZpZWxkX2luZm8OZmllbGRfaW5mb19tdXQQaGFzX2NoaWxkX29iamVjdBhoYXNfY2hpbGRfb2JqZWN0X3dpdGhfdHkRaGFzaF90eXBlX2FuZF9rZXkCaWQNaWRfdG9fYWRkcmVzcwRuYW1lEW5ld191aWRfZnJvbV9oYXNoBG5vbmUGb2JqZWN0Bm9wdGlvbgZyZW1vdmUTcmVtb3ZlX2NoaWxkX29iamVjdBByZW1vdmVfaWZfZXhpc3RzBHNvbWUOdWlkX3RvX2FkZHJlc3MFdmFsdWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAACAxQIAxYJACAJAQAUAAEAABEaCwAuERUMBQoFCgE4AAwECgUKBBEOIAQOBRAHACcLBBEUCwELAjkADAMLBQsDOAECAQEAAAwKCgARFQsBOAAMAgsACwI4AjcAAgIBAAAMCwoALhEVCwE4AAwCCwALAjgDNgACAwEAABYRCwAuERUMAwoDCwE4AAwCCwMLAjgEOgAMBAEREgsEAgQBAAAPCwsAERUMAwoDCwE4AAwCCwMLAhEOAgUBAAAXEwoACgEMAi4LAjgFBA0LAAsBOAY4BwwDBRELAAE4CAwDCwMCBgEAAA8LCwARFQwDCgMLATgADAILAwsCOAkCBwMAABkWCgARFQsBOAAMAwsACwM4CgwCCgI3AQwECgI3AgELAjcDDAULBAsFERMCCAMAAB0YCgAuERULATgADAMLAAsDOAsMAgoCNgEMBAoCNgIBCwI2AwwFCwQLBS4REwIJAwIACgMCAAsDAgAMAwIADQMCAA4DAgAPAwIAAAIAAAABABQBGwIbABsADAAOcHJpb3JpdHlfcXVldWXQCqEc6wsGAAAADQEABAIEDAMQPARMCgVWpwEH/QG4AQi1A0AG9QMOCoMEEguVBAQMmQTzBQ2MCgQOkAoEAAsBEAABBgECAAAABgECAAAGAAEBAgAIAgMBAgAEBAUBAgAHAwYBAgACBwABAgANCAUBAgAFCQUBAgAJCgsBAgEMDw0BAAEODw0BAAYNCQYFDQgQCA0BCgsBAQkAAQsAAQkAAQcLAAEJAAIDCQADBwsAAQkAAwkAAAELAQEJAAIKAwoJAAIHCgsBAQkAAwMHCgsBAQkAAwMBBgsAAQkAAQoDAgMDAQkAAwMDCQACBwoJAAMBAwUDAwMKCwEBCQAJAAUHCgsBAQkAAwcKCwEBCQADAw0HCgsBAQkAAQMHCgsBAQkAAwEHCgsBAQkAAwcKCwEBCQADAwMDAgMKAwVFbnRyeQ1Qcmlvcml0eVF1ZXVlDmNyZWF0ZV9lbnRyaWVzB2VudHJpZXMGaW5zZXJ0FW1heF9oZWFwaWZ5X3JlY3Vyc2l2ZQNuZXcJbmV3X2VudHJ5B3BvcF9tYXgKcHJpb3JpdGllcwhwcmlvcml0eQ5wcmlvcml0eV9xdWV1ZQZyZW1vdmUWcmVzdG9yZV9oZWFwX3JlY3Vyc2l2ZQtzd2FwX3JlbW92ZQV2YWx1ZQZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAoDAQAAAgEDCgsBAQkAAQICCgMPCQAADQENAAEAAAwYDgBBBgwCCgIGAgAAAAAAAAAaDAEKAQYAAAAAAAAAACQEFQUMCwEGAQAAAAAAAAAXDAENAAoCCgE4AAUHCwA5AAIBAQAADh4KADcAQQYMAQoBBgAAAAAAAAAAJAQJBQ0LAAEHACcKADYABgAAAAAAAAAAOAE6AQwDDAILADYACwEGAQAAAAAAAAAXBgAAAAAAAAAAOAALAgsDAgIBAAAQEQoANgALAQsCOQFEBgoANwBBBgYBAAAAAAAAABcMAwsANgALAzgCAgMBAAAFBAsACwE5AQIEAQAAESgOAEEQDAMOAUENCgMhBAkFCwYAAAAAAAAAACdABgAAAAAAAAAADAUGAAAAAAAAAAAMAgoCCgMjBCYFFA0ABgAAAAAAAAAAOAMMBA0BBgAAAAAAAAAAOAQMBg0FCwQLBjkBRAYLAgYBAAAAAAAAABYMAgUPCwUCBQAAABIuCgEGAAAAAAAAAAAhBAcLAAECCgEGAQAAAAAAAAAXBgIAAAAAAAAAGgwGCgAKAQwDDAIKAAoGDAUMBAsCLgsDQgY3ARQLBC4LBUIGNwEUJAQrCgALAQoGRwYLAAsGOAIFLQsAAQIGAAAAE24KAQYAAAAAAAAAACEEBwsAAQIKAgoBIwQMBRALAAEGAQAAAAAAAAAnCgIGAgAAAAAAAAAYBgEAAAAAAAAAFgwNCg0GAQAAAAAAAAAWDA8KAgwOCg0KASMENwoACg0MBQwDCgAKDgwHDAYLAy4LBUIGNwEUCwYuCwdCBjcBFCQMCAU5CQwICwgEPQsNDA4KDwoBIwRYCgAKDwwKDAkKAAoODAwMCwsJLgsKQgY3ARQLCy4LDEIGNwEUJAwEBVoJDAQLBAReCw8MDgoOCgIiBGsKAAoOCwJHBgsACwELDjgABW0LAAECBwEAABQcBwEMAgYAAAAAAAAAAAwBCgEKADcAQQYjBBgFCw0CCgA3AAoBQgY3ARREEAsBBgEAAAAAAAAAFgwBBQQLAAELAgIAAAEAAA0BDQAPdHJhbnNmZXJfcG9saWN5+xGhHOsLBgAAAA0BABgCGE4DZvMBBNkCKgWDA5YDB5kG5QQI/gpABr4LPAr6CzcLsQwKDLsM4QQNnBEQDqwREAA7AS8BPQATABUAHAAfAC4AMAA5ADwAQgAKAAEAAQAHDAEAAQAIDAEAAQAJAwEAAQAFBwECAQEDBwEAAAIMBwADAAQBAAEEAQwBAAEHAgcABw0EAAgEDAAJBgIACgsCAAsOBwEDAAAtAAEBAAAsAgMBAABDBAUBAAAZBgUBAAAWBwABAAARCAkDAAIGACUKCwMAAgYAEgwJAgACABANCQIAAgAmDg8CAAIANhAJAwACBgA+DhEBAAA/EBIBAAArExQBAAAxExUBAAAhExQBAAEaJBgBAAEqIw8BAAIkCRYBAANBJRUBAANECR8BAAQiKScBAAQzNQkBAAQ6JicBAAUPMQkCBwQFFDM0AgcEBSAzDwEHBTU3LwIHBAYdGAkBAwcYHAkAByciFAEIBywbHAAHQBEUAAgjGg8BAAsXLQ8BAwseCRcBAwsoMgkBAwspFysBAws4LBUBAyMWIRgcHRQeHiERFRAVEx4XHhUeJRYmFiIWCS4YMBIvJBYZMBYeGjYbMAMICQMICQELAAEJAAIGCAsHCA0CCwEBCQALAgEJAAQHCwEBCQAGCwIBCQALBQEDBwgNAQsIAQgMAwsBAQkACwIBCQAHCA0CBgsBAQkACwABCQAECQEHCwEBCQAGCwIBCQAJAgACCQEGCwEBCQABBgkCAwkBBwsBAQkACwgBCAwCCQEHCwABCQABBgsBAQkAAQECBwsBAQkABgsCAQkAAQYICgEHCAoBBgsAAQkAAQgJAQMBCAYBCw4BCQABCQAFCAoLDgEIBgsHAQgMCAoICQEGCAsBBwgNAQgKAQsDAQkAAQgMAQsHAQkAAwMDAwELAQEJAAEGCQABBgsFAQkAAQsFAQkAAQYLBwEJAAMHCwcBCQADBwgNAQsIAQkAAgsHAQgMCAoCCwcBCQAHCA0HCggGCAkICQMLDgEIBggGAwEKCQABBgsOAQkAAgYLDgEJAAYJAAIJAAkBAQkBAgsEAQkBCQIDBwgKCQAJAQIHCw4BCQAJAAIGCAoJAAEGCQECBwsHAQkACwgBCQABCwQBCQECBwgKCQAHQmFsYW5jZQRDb2luAklEBk9wdGlvbglQdWJsaXNoZXIHUnVsZUtleQNTVUkOVHJhbnNmZXJQb2xpY3kRVHJhbnNmZXJQb2xpY3lDYXAVVHJhbnNmZXJQb2xpY3lDcmVhdGVkD1RyYW5zZmVyUmVxdWVzdAlUeENvbnRleHQIVHlwZU5hbWUDVUlEBlZlY1NldANhZGQLYWRkX3JlY2VpcHQIYWRkX3J1bGUOYWRkX3RvX2JhbGFuY2UHYmFsYW5jZQZib3Jyb3cEY29pbg9jb25maXJtX3JlcXVlc3QIY29udGFpbnMGZGVsZXRlFGRlc3Ryb3lfYW5kX3dpdGhkcmF3DGRlc3Ryb3lfc29tZQtkdW1teV9maWVsZA1keW5hbWljX2ZpZWxkBGVtaXQFZW1wdHkFZXZlbnQHZXhpc3RzXwRmcm9tDGZyb21fYmFsYW5jZQxmcm9tX3BhY2thZ2UDZ2V0CGdldF9ydWxlCGhhc19ydWxlAmlkBmluc2VydAlpbnRvX2tleXMHaXNfc29tZQRpdGVtA25ldwtuZXdfcmVxdWVzdAZvYmplY3QGb3B0aW9uB3BhY2thZ2UEcGFpZAlwb2xpY3lfaWQDcHV0CHJlY2VpcHRzBnJlbW92ZQtyZW1vdmVfcnVsZQVydWxlcwRzaXplA3N1aQR0YWtlD3RyYW5zZmVyX3BvbGljeQp0eF9jb250ZXh0CXR5cGVfbmFtZQN1aWQQdWlkX211dF9hc19vd25lcgx1aWRfdG9faW5uZXIFdmFsdWUHdmVjX3NldAh3aXRoZHJhdwR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAACBCsICTEDIQgJNAsOAQgGAQIDJwgKEwsHAQgMNwsOAQgGAgICJwgKMggJAwIBJwgJBAIBGwEAGAMYARgCGAQvAAEAAAkGCwALAQsCOAA5AAIBAQAAGSALADgBBAQFCAsBAQYAAAAAAAAAACcKAREfDAUOBREgDAYKBjkBOAILBQwCOAAMAzgDDAQLAgsECwM5AgsBER8LBjkDAgIBAAAgMQoALjgECwE3ABQhBAkFDwsAAQsDAQcEJw4COAUEJQsCOAYMBgoGCgA3ATgHJQQcBSILAAELAwEHBScLBgwEBSkKADcBOAcMBAsEDAULADYBCwULAzgIAgMBAAAoGw4AOAQOATcAFCEECAUMCwIBBwQnCwE6AwEMBAsAOgIBDAMRHQsEER0LAwsCOAkCBAEAACo0CwE6AAwGDAMMBQwECwY4CgwCDgJBFgwICggKADcCOAshBBMFFwsAAQcAJwoIBgAAAAAAAAAAJAQuBRwNAkUWDAcKADcCDgc4DAQlBSkLAAEHAScLCAYBAAAAAAAAABcMCAUXCwABCwQLBQsDAgUBAAAJIgoBLjgECwI3ABQhBAkFDQsBAQcEJwoBLjgNIAQTBRcLAQEHAycKATYDCTkECwM4DgsBNgI4DzgQAgYBAAAJBgsBNwMJOQQ4EQIHAQAACQ4KAS44DQQFBQkLAQEHAicLATYBCwI4EgIIAQAACQULATYEOA84EAIJAQAACQYLADcDCTkEOBMCCgEAAAkUCgAuOAQLATcAFCEECQUNCwABBwQnCwA2Awk5BDgUAQILAQAACQMLADcDAgwBAAAJEAoALjgECwE3ABQhBAkFDQsAAQcEJwsANgMCDQEAAAkECwA3BRQCDgEAAAkECwA3BhQCDwEAAAkECwA3BxQCAgEBAQECAQAAAwAAAAEAAgAYARgCGAMYBBgFGAYYBxgAFGR5bmFtaWNfb2JqZWN0X2ZpZWxk2QehHOsLBgAAAAoBAAgCCBQDHIoBBKYBGgXAAYMBB8MCsgII9QRACrUFBgu7BQIMvQXpAQALARYACgAVAAMHAQAAAQEHAQAAAwAHAAMCBAAABAABAgcMAAYCAwIHDAAJBAUCBwwAFwQGAgcMAAwCBwEHAA0CBwIHDAARAggBBwEUARgBAAEZChgBAAIEAAECBwQCBRIBAQgCBw8LAQgCCBMUAQgCDQIHAgcEAg4CDwEHAg8EEwEHAhAWBwEIAhcEBgIHBAIYFgoBCAMRCwwBCAMSEQwAAxoQEQATBgkNDg4KBgsGDw4MBhIGEQ0NDRAGBwwIDAMHCAMJAAkBAAIGCAMJAAEGCQECBwgDCQABBwkBAQkBAQEBCwEBCAIDCwABCQAIAgsAAQkAAQkAAQYJAAEIAgILAAEJAAgCAQsAAQkAAgYIAwUBBggDAQUCBQkAAgcIAwUBBwkABAsAAQkACwABCQAJAQUCBQUCCwABCQAFAQsBAQkAAklEBk9wdGlvbgNVSUQHV3JhcHBlcgNhZGQQYWRkX2NoaWxkX29iamVjdAZib3Jyb3cTYm9ycm93X2NoaWxkX29iamVjdBdib3Jyb3dfY2hpbGRfb2JqZWN0X211dApib3Jyb3dfbXV0DWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlCmZpZWxkX2luZm8OZmllbGRfaW5mb19tdXQYaGFzX2NoaWxkX29iamVjdF93aXRoX3R5AmlkD2lkX2Zyb21fYWRkcmVzcwRuYW1lBG5vbmUGb2JqZWN0Bm9wdGlvbgZyZW1vdmUTcmVtb3ZlX2NoaWxkX29iamVjdARzb21lDnVpZF90b19hZGRyZXNzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQACARMJAAAKAAEAAAkVCwE5AAwFDgI4AAwECgAKBQsEOAELAAsFDAMuCwM4AgERFQsCOAMCAQEAAA4ICwE5AAwCCwALAjgCOAQCAgEAAA4ICwE5AAwCCwALAjgFOAYCAwEAABUUCwE5AAwDCgAKAwwCLgsCOAIMBREVCwU4BwwECwALAzgIAQsEAgQBAAAOBwsBOQAMAgsACwI4CQIFAQAAFxQLATkADAIKAAoCOAkgBAwLAAEJAgsACwI4AgwDERULAzgKAgYBAAAXFQsBOQAMAgoACgI4CSAEDAsAATgLAgsACwI4AgwDAQsDERQ4DAIANwp0eF9jb250ZXh0CVR4Q29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdAJJRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdANVSUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDYmFnA0JhZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2JhbGFuY2UGU3VwcGx5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHYmFsYW5jZQdCYWxhbmNlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDYmNzA0JDUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBmJvcnJvdwhSZWZlcmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBmJvcnJvdwZCb3Jyb3cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVjbG9jawVDbG9jawAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3VybANVcmwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luBENvaW4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luDENvaW5NZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBGNvaW4LVHJlYXN1cnlDYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luD0N1cnJlbmN5Q3JlYXRlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3ZlY19tYXAGVmVjTWFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHdmVjX21hcAVFbnRyeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3BhY2thZ2UJUHVibGlzaGVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQpVcGdyYWRlQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQ1VcGdyYWRlVGlja2V0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQ5VcGdyYWRlUmVjZWlwdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2Rpc3BsYXkHRGlzcGxheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2Rpc3BsYXkORGlzcGxheUNyZWF0ZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdkaXNwbGF5DlZlcnNpb25VcGRhdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIUZHluYW1pY19vYmplY3RfZmllbGQHV3JhcHBlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2dyb3RoMTYFQ3VydmUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdncm90aDE2FFByZXBhcmVkVmVyaWZ5aW5nS2V5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHZ3JvdGgxNhFQdWJsaWNQcm9vZklucHV0cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2dyb3RoMTYLUHJvb2ZQb2ludHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgd2ZWNfc2V0BlZlY1NldAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3N1aQNTVUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg90cmFuc2Zlcl9wb2xpY3kPVHJhbnNmZXJSZXF1ZXN0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5DlRyYW5zZmVyUG9saWN5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5EVRyYW5zZmVyUG9saWN5Q2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5FVRyYW5zZmVyUG9saWN5Q3JlYXRlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD3RyYW5zZmVyX3BvbGljeQdSdWxlS2V5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sFS2lvc2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zaw1LaW9za093bmVyQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sLUHVyY2hhc2VDYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawZCb3Jyb3cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawRJdGVtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sHTGlzdGluZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBWtpb3NrBExvY2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawpJdGVtTGlzdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMbGlua2VkX3RhYmxlC0xpbmtlZFRhYmxlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMbGlua2VkX3RhYmxlBE5vZGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgpvYmplY3RfYmFnCU9iamVjdEJhZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDG9iamVjdF90YWJsZQtPYmplY3RUYWJsZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDnByaW9yaXR5X3F1ZXVlDVByaW9yaXR5UXVldWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg5wcmlvcml0eV9xdWV1ZQVFbnRyeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBXRhYmxlBVRhYmxlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJdGFibGVfdmVjCFRhYmxlVmVjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJdmVyc2lvbmVkCVZlcnNpb25lZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCXZlcnNpb25lZBBWZXJzaW9uQ2hhbmdlQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAAAAAAAAAwABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBAAAAAAAAAAsHZ2VuZXNpc4AToRzrCwYAAAALAQAaAho6A1RrBL8BDgXNAbACB/0DiQkIhg1gBuYNFAr6DV0M1w7bAw2yEhgAHwEsAUgCEgIUAisCPQJCADYAPwBAAEMARgADAwAAAgMAAAkAAAAIAAABBAcBAAADAAQBAAEEAQwBAAEFCwQABgUCAAcKAgAIBgQACgcEAAsMBAAAFgABAAAPAgEAAA4DAQABGRkaAQABJBgOAQACIxYOAQADGgkBAQADNQgJAQADSwEJAQAEHR4fAQAGQSABAAcbBQYACBYREgAJFhMBAAoXDxAACw0iAQALKgwKAAs0HQEADCAbHAAMIg0OAAcHCAcFFQQXAxcJBwYHBggHCwUBCAgIAQoIAAgCBwgJAAQLBQEICAoIAwcKCAwHCAkBBwoIDBkKCAMDAwoCAwMKAgoCCgIKAgoCCgIKAgoCCgIICgMLBQEICAsFAQgIBQgLCAwKCAwKAgoCAQYICQEDAQgIAgcLBQEJAAMBCwUBCQABCAwBCAAQBQoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgJAgYKCAwGCAwBAQgDAwMDAwMDBwgJAQgLBQsFAQgIAwMNBwgJAQgKCAgHCggMCwUBCAgDAwgLCAoHCAkFCwUBCAgDBQsEAQUFAQgDAQYKCQABBQEGCwQBCQABCwQBCQABCQACBwoIDAUBBwgMBAcIDAsFAQgIBQcICQILBQEJAAcICQELBgEJAAILBgEICAUCAwMCBwgMAwdCYWxhbmNlBENvaW4WR2VuZXNpc0NoYWluUGFyYW1ldGVycxhHZW5lc2lzVmFsaWRhdG9yTWV0YWRhdGEGT3B0aW9uA1NVSQxTdGFrZVN1YnNpZHkQU3lzdGVtUGFyYW1ldGVycw9Ub2tlbkFsbG9jYXRpb24ZVG9rZW5EaXN0cmlidXRpb25TY2hlZHVsZQlUeENvbnRleHQDVUlECVZhbGlkYXRvcghhY3RpdmF0ZRNhY3RpdmF0ZV92YWxpZGF0b3JzD2FsbG9jYXRlX3Rva2VucwthbGxvY2F0aW9ucwthbW91bnRfbWlzdAdiYWxhbmNlGGNoYWluX3N0YXJ0X3RpbWVzdGFtcF9tcwRjb2luD2NvbW1pc3Npb25fcmF0ZQZjcmVhdGUYY3JlYXRlX3N5c3RlbV9wYXJhbWV0ZXJzC2Rlc2NyaXB0aW9uDGRlc3Ryb3lfc29tZQxkZXN0cm95X3plcm8FZXBvY2gRZXBvY2hfZHVyYXRpb25fbXMMZnJvbV9iYWxhbmNlCWdhc19wcmljZQdnZW5lc2lzEWdldF92YWxpZGF0b3JfbXV0CWltYWdlX3VybBZpc19kdXBsaWNhdGVfdmFsaWRhdG9yCGlzX2VtcHR5B2lzX3NvbWUTbWF4X3ZhbGlkYXRvcl9jb3VudBttaW5fdmFsaWRhdG9yX2pvaW5pbmdfc3Rha2UEbmFtZQ9uZXR3b3JrX2FkZHJlc3MSbmV0d29ya19wdWJsaWNfa2V5A25ldwZvYmplY3QGb3B0aW9uC3AycF9hZGRyZXNzD3ByaW1hcnlfYWRkcmVzcwtwcm9qZWN0X3VybBNwcm9vZl9vZl9wb3NzZXNzaW9uE3Byb3RvY29sX3B1YmxpY19rZXkQcHJvdG9jb2xfdmVyc2lvbhFyZWNpcGllbnRfYWRkcmVzcxxyZXF1ZXN0X2FkZF9zdGFrZV9hdF9nZW5lc2lzBXNwbGl0DXN0YWtlX3N1YnNpZHkbc3Rha2Vfc3Vic2lkeV9kZWNyZWFzZV9yYXRlF3N0YWtlX3N1YnNpZHlfZnVuZF9taXN0KXN0YWtlX3N1YnNpZHlfaW5pdGlhbF9kaXN0cmlidXRpb25fYW1vdW50G3N0YWtlX3N1YnNpZHlfcGVyaW9kX2xlbmd0aBlzdGFrZV9zdWJzaWR5X3N0YXJ0X2Vwb2NoFXN0YWtlZF93aXRoX3ZhbGlkYXRvcgNzdWkLc3VpX2FkZHJlc3MKc3VpX3N5c3RlbRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyCHRyYW5zZmVyCnR4X2NvbnRleHQJdmFsaWRhdG9yIHZhbGlkYXRvcl9sb3dfc3Rha2VfZ3JhY2VfcGVyaW9kHXZhbGlkYXRvcl9sb3dfc3Rha2VfdGhyZXNob2xkDXZhbGlkYXRvcl9zZXQidmFsaWRhdG9yX3ZlcnlfbG93X3N0YWtlX3RocmVzaG9sZAZ2ZWN0b3IOd29ya2VyX2FkZHJlc3MRd29ya2VyX3B1YmxpY19rZXkEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAAIPJwoCGAoCIQoCLwoCPgUeAxUDMQoCMAoCKQoCSgoCKAoCLQoCLgoCSQoCAQIMMgMTAxwDOwM5AzoDNw0lAyYDRQNHA0QDAgICOAMQCggDAwIDMwURAzwLBAEFAAAAAASTAQoFLhELBgAAAAAAAAAAIQQHBQsLBQEHACcLBBMCDAYMFg0BCxY4AAwYOAEMF0AKAAAAAAAAAAAMHA4DQQsMCAYAAAAAAAAAAAwLCgsKCCMEWQUhDgMKC0ILFBMADB0MEQwQDA4MHgwPDBMMFAwHDAoMGQwSDAwMCQwNCxkLFAsPCx4LEwsNCwkLDAsSCw4LEAsRCx0LCgsHCgUREAwbDhwOGxETIARNBVELBQEHAScNHAsbRAoLCwYBAAAAAAAAABYMCwUcCwELBg0cCgURAQ0cEQIOAhAAFA4CEAEUDgIQAhQOAhADFA4CEAQUDgIQBRQOAhAGFAoFEQ4MGgsYDgIQBxQOAhAIFA4CEAkUCgURDAwVCwALHAsXDgIQChQOAhALFAsaCxULBRENAgEAAAAULA4BOAIgBCMFBQ0BRRUTAwwHDAUMBg0ACwU4AAwEDgc4AwQdCwc4BAwICgILCBESCwQLBgoDEREFIgsECgM4BQsGEQoFAAsCAQsDAQsBRhUAAAAAAAAAAAsAOAYCAgAAACEYCgAuQQoMAQYAAAAAAAAAAAwCCgIKASMEFQULCgAKAkMKBgAAAAAAAAAAEQ8LAgYBAAAAAAAAABYMAgUGCwABAgECAQMBBwEIAQkBCgELAQQBBQEGAQABAQAJdmFsaWRhdG9y0jyhHOsLBgAAAAwBAB8CH0gDZ7cEBJ4FJgXEBfADB7QJyRMI/RxgBt0dqgEKhx+cAQyjIKkbDcw7PA+IPA0AhgEBFAEXAUkBZwIVAhYCIgJHAmgCbwKDAQBlAIgBAA4EAAANBAAACAMAAAsDAAEJBwADAwcBAAAECQcABQAMAAYBBAEAAQgCBwAJBQIACgoCAAsMBwAMBAcADAYIAAwHDAANDwIAADcAAQAANQIDAAAaBAUAABAEBQAAEgYFAABWBwUAAFcHBQAAWggFAABZCQUAAF4JBQAAWAQFAABdBAUAAB0KBQAAUgsFAAAuDA0AADAMDgAAaQwPAAAxDBAAAB4MEAAAKQwRAABTDBEAADMMEAAASgwQAABPDBAAAI4BDBAAAFUMEgAAVAwSAAA0DBIAAI8BDBIAAD0MEwAAPwwTAABADBMAAEQMEwAAQgwUAABBDBQAAD4MFAAARQwUAABIDBUAADsMFgAAbgwWAABiDBYAAG0MFgAAjQEMFgAAXwQFAABLDBYAAEwMFgAAJgwWAAAZDBYAAE4XGAAAZgwZAAAqGg0AACwbDQEAACscDQEAADkLBQAAeh0FAAB4HQUAAHkdBQAAggEdBQAAex0FAABxHQUAAH0dBQAAcx0FAAB+HQUAAHQdBQAAgAEdBQAAdh0FAAB/HgUAAHUeBQAAfB0FAAByHQUAAIEBHQUAAHcdBQAAHwYFAACEAQ4FAACFAR8FAAA2IAMAAWcfJgACbD4fAQADGEA+AQADJEMzAQADLUANAQADL0ANAQADRgUiAQADYDMiAQAEJSYjAAU1KCkABosBLRYBAAcgMwUBAwgoPhkBCAohLhYAClwuDwALOB8nAAwRKgUADBsqBQAMHDoFAAwuMA0ADDUoPQAMSzAWAAxMMBYADE48GAAMUTEFAAxSOwUADFYvBQAMWjYWAAxhNRYADGM1FgAMajAWAA05QhkADYwBODkAUh9SI1YsVzJXN1g9NCM0HzMjMx9QM04zUyNTH1EjTyNRH08fTQEOBQoCCgIKAgoCCAYIBggMCAwIBggGCAYIBggHAQgAEAUKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIDAwcICwEIAQIHCAEDAAEHCAEEBwgBCwgBCAoFBwgLAwcIAQgOBwgLAwcIAQgQAwIHCAELCAEICgIHCAEHCAsBBggBAQEBBggAAQUBBggGAQYIDAEGCgIBBgsFAQgGAQYLBQEKAgEGCAkBAwIGCAEDAQgNAQgJAgYIAQYIAQIGCwUBCQAGCQACBgsFAQkABgsFAQkAAgcIAQoCAwcIAQoCCgIBCgIECAADAwcICxYFCAYIBggGCAYLBQEKAgsFAQoCCwUBCgILBQEKAgsFAQgGCwUBCAYKAgsFAQgGCwUBCAYIBwoCCgIKAggGCAYIDAgMAQsFAQkAAQgGCAEBAQEBAQEIAAECAQgEAQgMAQcICwEIBwIHCA8DAgMDAQgKAQYLCAEJAAEGCAsFBwgPCwgBCAoFAwcICwEGCA8BBwgPAQgCAQkABAMDAwMBBggOAwcIDwgOBwgLAQgDAQYIEAEGBQIHCA8LCAEICgIHCA8HCAsCBggPAwEIDwEGCQAdAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBBgsFAQkAAgEBAgUHCAsBBwsFAQkAAwgJCA8FA0JhZwdCYWxhbmNlAklEBk9wdGlvbhVQb29sVG9rZW5FeGNoYW5nZVJhdGUDU1VJCVN0YWtlZFN1aQtTdGFraW5nUG9vbBNTdGFraW5nUmVxdWVzdEV2ZW50BlN0cmluZwlUeENvbnRleHQVVW5zdGFraW5nUmVxdWVzdEV2ZW50A1VybAlWYWxpZGF0b3IRVmFsaWRhdG9yTWV0YWRhdGEVVmFsaWRhdG9yT3BlcmF0aW9uQ2FwCGFjdGl2YXRlFWFjdGl2YXRlX3N0YWtpbmdfcG9vbBphZGp1c3Rfc3Rha2VfYW5kX2dhc19wcmljZQZhbW91bnQFYXNjaWkDYmFnB2JhbGFuY2UDYmNzBmJvcnJvdw9jb21taXNzaW9uX3JhdGUKZGVhY3RpdmF0ZRdkZWFjdGl2YXRlX3N0YWtpbmdfcG9vbA9kZXBvc2l0X3Jld2FyZHMVZGVwb3NpdF9zdGFrZV9yZXdhcmRzC2Rlc2NyaXB0aW9uGmVmZmVjdHVhdGVfc3RhZ2VkX21ldGFkYXRhBGVtaXQFZXBvY2gFZXZlbnQMZXh0cmFfZmllbGRzB2V4dHJhY3QKZnJvbV9hc2NpaQlnYXNfcHJpY2UHZ2VuZXNpcwJpZAlpbWFnZV91cmwMaXNfZHVwbGljYXRlDWlzX2VxdWFsX3NvbWUXaXNfZXF1YWxfc29tZV9hbmRfdmFsdWUHaXNfbm9uZQxpc19wcmVhY3RpdmUHaXNfc29tZQhtZXRhZGF0YQRuYW1lC25ldF9hZGRyZXNzD25ldHdvcmtfYWRkcmVzcxRuZXR3b3JrX3B1YmtleV9ieXRlcwNuZXcRbmV3X2Zyb21fbWV0YWRhdGEMbmV3X21ldGFkYXRhFW5ld191bnNhZmVfZnJvbV9ieXRlczNuZXdfdW52ZXJpZmllZF92YWxpZGF0b3Jfb3BlcmF0aW9uX2NhcF9hbmRfdHJhbnNmZXIabmV4dF9lcG9jaF9jb21taXNzaW9uX3JhdGUUbmV4dF9lcG9jaF9nYXNfcHJpY2UWbmV4dF9lcG9jaF9uZXRfYWRkcmVzcxpuZXh0X2Vwb2NoX25ldHdvcmtfYWRkcmVzcx9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5X2J5dGVzFm5leHRfZXBvY2hfcDJwX2FkZHJlc3MabmV4dF9lcG9jaF9wcmltYXJ5X2FkZHJlc3MebmV4dF9lcG9jaF9wcm9vZl9vZl9wb3NzZXNzaW9uIG5leHRfZXBvY2hfcHJvdG9jb2xfcHVia2V5X2J5dGVzEG5leHRfZXBvY2hfc3Rha2UZbmV4dF9lcG9jaF93b3JrZXJfYWRkcmVzcx5uZXh0X2Vwb2NoX3dvcmtlcl9wdWJrZXlfYnl0ZXMEbm9uZQZvYmplY3QQb3BlcmF0aW9uX2NhcF9pZAZvcHRpb24LcDJwX2FkZHJlc3MUcGVuZGluZ19zdGFrZV9hbW91bnQdcGVuZGluZ19zdGFrZV93aXRoZHJhd19hbW91bnQHcG9vbF9pZCFwb29sX3Rva2VuX2V4Y2hhbmdlX3JhdGVfYXRfZXBvY2gPcHJpbWFyeV9hZGRyZXNzEHByaW5jaXBhbF9hbW91bnQVcHJvY2Vzc19wZW5kaW5nX3N0YWtlJHByb2Nlc3NfcGVuZGluZ19zdGFrZXNfYW5kX3dpdGhkcmF3cwtwcm9qZWN0X3VybBNwcm9vZl9vZl9wb3NzZXNzaW9uFXByb3RvY29sX3B1YmtleV9ieXRlcxFyZXF1ZXN0X2FkZF9zdGFrZRxyZXF1ZXN0X2FkZF9zdGFrZV9hdF9nZW5lc2lzG3JlcXVlc3Rfc2V0X2NvbW1pc3Npb25fcmF0ZRVyZXF1ZXN0X3NldF9nYXNfcHJpY2UWcmVxdWVzdF93aXRoZHJhd19zdGFrZQ1yZXdhcmRfYW1vdW50BnNlbmRlch1zZXRfY2FuZGlkYXRlX2NvbW1pc3Npb25fcmF0ZRdzZXRfY2FuZGlkYXRlX2dhc19wcmljZRBzZXRfdm90aW5nX3Bvd2VyBHNvbWUWc3Rha2VfYWN0aXZhdGlvbl9lcG9jaAxzdGFrZV9hbW91bnQRc3Rha2VkX3N1aV9hbW91bnQOc3Rha2VyX2FkZHJlc3MMc3Rha2luZ19wb29sD3N0YWtpbmdfcG9vbF9pZAZzdHJpbmcDc3VpC3N1aV9hZGRyZXNzC3N1aV9iYWxhbmNlFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIIdG9fYnl0ZXMLdG90YWxfc3Rha2USdG90YWxfc3Rha2VfYW1vdW50CnR4X2NvbnRleHQPdW5zdGFraW5nX2Vwb2NoIHVwZGF0ZV9jYW5kaWRhdGVfbmV0d29ya19hZGRyZXNzH3VwZGF0ZV9jYW5kaWRhdGVfbmV0d29ya19wdWJrZXkcdXBkYXRlX2NhbmRpZGF0ZV9wMnBfYWRkcmVzcyB1cGRhdGVfY2FuZGlkYXRlX3ByaW1hcnlfYWRkcmVzcyB1cGRhdGVfY2FuZGlkYXRlX3Byb3RvY29sX3B1YmtleR91cGRhdGVfY2FuZGlkYXRlX3dvcmtlcl9hZGRyZXNzHnVwZGF0ZV9jYW5kaWRhdGVfd29ya2VyX3B1YmtleRJ1cGRhdGVfZGVzY3JpcHRpb24QdXBkYXRlX2ltYWdlX3VybAt1cGRhdGVfbmFtZSF1cGRhdGVfbmV4dF9lcG9jaF9uZXR3b3JrX2FkZHJlc3MgdXBkYXRlX25leHRfZXBvY2hfbmV0d29ya19wdWJrZXkddXBkYXRlX25leHRfZXBvY2hfcDJwX2FkZHJlc3MhdXBkYXRlX25leHRfZXBvY2hfcHJpbWFyeV9hZGRyZXNzIXVwZGF0ZV9uZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleSB1cGRhdGVfbmV4dF9lcG9jaF93b3JrZXJfYWRkcmVzcx91cGRhdGVfbmV4dF9lcG9jaF93b3JrZXJfcHVia2V5EnVwZGF0ZV9wcm9qZWN0X3VybAN1cmwRdmFsaWRhdGVfbWV0YWRhdGEVdmFsaWRhdGVfbWV0YWRhdGFfYmNzCXZhbGlkYXRvchF2YWxpZGF0b3JfYWRkcmVzcw12YWxpZGF0b3JfY2FwDXZhbGlkYXRvcl9zZXQRdmFsaWRhdG9yX3dyYXBwZXIFdmFsdWUedmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzDHZvdGluZ19wb3dlcg53b3JrZXJfYWRkcmVzcxN3b3JrZXJfcHVia2V5X2J5dGVzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMICgAAAAAAAAADCAsAAAAAAAAAAwgMAAAAAAAAAAMIZAAAAAAAAAADCGUAAAAAAAAAAwgQJwAAAAAAAAMIAAEAAAAAAAAAAhZpBVUKAjQKAo8BCgJUCgIxCAYeCAYpCAxTCAwyCAZKCAZPCAaOAQgGQgsFAQoCQQsFAQoCPgsFAQoCRQsFAQoCPAsFAQgGPwsFAQgGQAsFAQgGRAsFAQgGIwgHAQIKMAgAjQEDSAgJJgNlCA8ZA0MDOwM6AyMIBwICBU0ICYcBBWQFIQMTAwMCB00ICYcBBWQFYQNwA1ADWwMAAwAAIUQLAAwOCwEMGQsCDB0LAwweCwQMHwsFDCALBgwhCwcMIgsIDCMLCQwPCwoMEAsLDBELDAwSOAAMEzgADBQ4AAwVOAAMFjgBDBc4AQwYOAEMGjgBDBsLDQwcCw4LGQsdCx4LHwsgCyELIgsjCw8LEAsRCxILEwsWCxQLFQsXCxgLGgsbCxwSAAIBAwAAJIABDglBJQcQJQQLDgpBJQcQJQwQBQ0JDBALEAQVDgtBJQcQJQwRBRcJDBELEQQfDgxBJQcQJQwSBSEJDBILEgQpDgVBJQcQJQwTBSsJDBMLEwQzDgZBJQcQJQwUBTUJDBQLFAQ9DgdBJQcQJQwVBT8JDBULFQRHDghBJQcQJQwWBUkJDBYLFgRMBVALDwEHCScKDgcPJQRVBVkLDwEHCCcLAAsBCwILAwsECwURTBFUCwYRTBFUCwcRWwsIEVsLCRFMEVQLChFMEVQLCxFMEVQLDBFMEVQKDxFVEQAMFw4XEUkLFwsNCw4LDxFLAgIDAAAFBQsADwALARFdAgMDAAAFBQsADwALARFcAgQDAAAFDQoAEAEUCgAPAhUKABADFAsADwQVAgUDAAArOQ4BOAIMBAoEBgAAAAAAAAAAJAQIBQ4LAAELAwEHCycKAy4RWQYBAAAAAAAAABYMBQoADwALAQoCCwUKAxFmCgAQABFfBCIKAA8AEWQKABAFFAoEFgoADwUVCgAuETELABAGEAcUCwILAy4RWQsEEgI4AwIGAwAAFi4KAy4RWQYAAAAAAAAAACEEBwUNCwABCwMBBwwnDgE4AgwECgQGAAAAAAAAAAAkBBUFGwsAAQsDAQcLJwoADwALAQsCBgAAAAAAAAAACwMRZgoADwARZAoAEAUUCwQWCwAPBRUCBwMAADQrDgERaQwDDgERaAwFCgAPAAsBCgIRZwwGCgYKAxcMBAoAEAUUCwYXCgAPBRUKAC4RMQsAEAYQBxQKAi4RWgsFCwIuEVkLAwsEEgM4BAIIAwAABRMOARFsFAoAEAYQBxQhBAoFDgsAAQcOJwsCCwAPARUCCQMAAAUgCgAuEQ4EBQUJCwABBwonDgERbBQKABAGEAcUIQQTBRcLAAEHDicKAgoADwEVCwILAA8CFQIKAwAABQ4KAQcPJQQFBQkLAAEHCCcLAQsADwMVAgsDAAAFFwoALhEOBAUFCQsAAQcKJwoBBw8lBA4FEgsAAQcIJwsBCwAPBBUCDAMAAAUOCgAQBRQOATgCFgoADwUVCwAPAAsBEV4CDQMAAAUQCgAPAAsBEWUKAC4RKAsAEAUUIQQNBQ8HCycCDgEAAAUECwAQABFfAg8BAAAFAwsAEAYCEAEAAAUFCwAQBhAHFAIRAQAABQQLABAGEAgCEgEAAAUECwAQBhAJAhMBAAAFBAsAEAYQCgIUAQAABQQLABAGEAsCFQEAAAUECwAQBhAMAhYBAAAFBAsAEAYQDQIXAQAABQQLABAGEA4CGAEAAAUECwAQBhAPAhkBAAAFBAsAEAYQEAIaAQAABQQLABAGEBECGwEAAAUECwAQBhASAhwBAAAFBAsAEAYQEwIdAQAABQQLABAGEBQCHgEAAAUECwAQBhAVAh8BAAAFBAsAEAYQFgIgAQAABQQLABAGEBcCIQEAAAUECwAQBhAYAiIBAAAFBAsAEAYQGQIjAQAABQQLABAGEBoCJAEAAAUECwAQBhAbAiUBAAAFAwsAEBwCJgEAAAUECwAQARQCJwEAAAUFKAsAEAARagIoAQAABQQLABAAEWoCKQEAAAUDCwARKAIqAQAABQQLABAdFAIrAwAABQULAQsADx0VAiwBAAAFBAsAEAARYQItAQAABQQLABAAEWICLgEAAAUECwAQAhQCLwEAAAUECwAQBBQCMAEAAAUFCwAQAAsBEWMCMQEAAAUECwAQADgFAjIBAAA/lwMKABAGEAcUCgEQBhAHFCEEDQgMAgUXCgAQBhAIFAoBEAYQCBQhDAILAgQcCAwNBSYKABAGEAwUCgEQBhAMFCEMDQsNBCsIDBgFNQoAEAYQDRQKARAGEA0UIQwYCxgEOggMGQVECgAQBhAQFAoBEAYQEBQhDBkLGQRJCAwaBVMKABAGEBIUCgEQBhASFCEMGgsaBFgIDBsFYgoAEAYQEhQKARAGEBMUIQwbCxsEZwgMHAVxCgAQBhATFAoBEAYQExQhDBwLHAR2CAwdBYABCgAQBhATFAoBEAYQEhQhDB0LHQSFAQgMHgWNAQoAEAYQFAoBEAYQFDgGDB4LHgSSAQgMAwWaAQoAEAYQFQoBEAYQFTgGDAMLAwSfAQgMBAWnAQoAEAYQGAoBEAYQGDgHDAQLBASsAQgMBQW0AQoAEAYQGgoBEAYQGjgHDAULBQS5AQgMBgXBAQoAEAYQGgoBEAYQGzgHDAYLBgTGAQgMBwXOAQoAEAYQGwoBEAYQGzgHDAcLBwTTAQgMCAXbAQoAEAYQGwoBEAYQGjgHDAgLCATgAQgMCQXoAQoAEAYQFAoBEAYQDDgIDAkLCQTtAQgMCgX1AQoAEAYQFQoBEAYQDTgIDAoLCgT6AQgMCwWCAgoAEAYQGAoBEAYQEDgJDAsLCwSHAggMDAWPAgoAEAYQGgoBEAYQEjgJDAwLDASUAggMDgWcAgoAEAYQGgoBEAYQEzgJDA4LDgShAggMDwWpAgoAEAYQGwoBEAYQEzgJDA8LDwSuAggMEAW2AgoAEAYQGwoBEAYQEjgJDBALEAS7AggMEQXDAgoBEAYQFAoAEAYQDDgIDBELEQTIAggMEgXQAgoBEAYQFQoAEAYQDTgIDBILEgTVAggMEwXdAgoBEAYQGAoAEAYQEDgJDBMLEwTiAggMFAXqAgoBEAYQGgoAEAYQEjgJDBQLFATvAggMFQX3AgoBEAYQGgoAEAYQEzgJDBULFQT8AggMFgWEAwoBEAYQGwoAEAYQEzgJDBYLFgSNAwsAAQsBAQgMFwWVAwsBEAYQGwsAEAYQEjgJDBcLFwIzAAAADREKADgKBAoLAQELAAEJDAIFDwsAOAsLASEMAgsCAjQAAABBGgoAOAoEBggMAgUJCgE4CgwCCwIEEgsBAQsAAQkMAwUYCwA4CwsBOAshDAMLAwI1AwAADxkKAS4RWgwCCgIKABAGEAcUIQQMBRILAAELAQEHDScLAgsBEWsLAA8cFQI2AwAABRIOAUElBxAlBAYFCgsAAQcJJwsBEUwRVAsADwYPCBUCNwMAAAUSDgFBJQcQJQQGBQoLAAEHCScLARFMEVQLAA8GDwkVAjgDAAAFEQ4BQSUHECUEBgUKCwABBwknCwERWwsADwYPChUCOQMAAAURDgFBJQcQJQQGBQoLAAEHCScLARFbCwAPBg8LFQI6AwAABRYOAUElBxAlBAYFCgsAAQcJJwsBEUwRVDgMCgAPBg8UFQsAEAYRSQI7AwAABR4KAC4RDgQFBQkLAAEHCicOAUElBxAlBA8FEwsAAQcJJwsBEUwRVAoADwYPDBULABAGEUkCPAMAAAUWDgFBJQcQJQQGBQoLAAEHCScLARFMEVQ4DAoADwYPFRULABAGEUkCPQMAAAUeCgAuEQ4EBQUJCwABBwonDgFBJQcQJQQPBRMLAAEHCScLARFMEVQKAA8GDw0VCwAQBhFJAj4DAAAFFg4BQSUHECUEBgUKCwABBwknCwERTBFUOAwKAA8GDxYVCwAQBhFJAj8DAAAFHgoALhEOBAUFCQsAAQcKJw4BQSUHECUEDwUTCwABBwknCwERTBFUCgAPBg8OFQsAEAYRSQJAAwAABRYOAUElBxAlBAYFCgsAAQcJJwsBEUwRVDgMCgAPBg8XFQsAEAYRSQJBAwAABR4KAC4RDgQFBQkLAAEHCicOAUElBxAlBA8FEwsAAQcJJwsBEUwRVAoADwYPDxULABAGEUkCQgMAAAUQCwE4DQoADwYPGBULAjgNCgAPBg8ZFQsAEAYRSQJDAwAABRcKAC4RDgQFBQkLAAEHCicLAQoADwYPEBULAgoADwYPERULABAGEUkCRAMAAAUKCwE4DQoADwYPGhULABAGEUkCRQMAAAUSCgAuEQ4EBQUJCwABBwonCwEKAA8GDxIVCwAQBhFJAkYDAAAFCgsBOA0KAA8GDxsVCwAQBhFJAkcDAAAFEgoALhEOBAUFCQsAAQcKJwsBCgAPBg8TFQsAEAYRSQJIAwAABY8BCgAuER04DgQSCgAPBg8UOA8KAA8GDwwVOAEKAA8GDxQVCgAuER44DgQkCgAPBg8VOA8KAA8GDw0VOAEKAA8GDxUVCgAuER84DgQ2CgAPBg8WOA8KAA8GDw4VOAEKAA8GDxYVCgAuESA4DgRICgAPBg8XOA8KAA8GDw8VOAEKAA8GDxcVCgAuESE4EARnCgAPBg8YOBEKAA8GDxAVOAAKAA8GDxgVCgAPBg8ZOBEKAA8GDxEVOAAKAA8GDxkVCgAuESM4EAR5CgAPBg8aOBEKAA8GDxIVOAAKAA8GDxoVCgAuESQ4EASMAQoADwYPGzgRCgAPBg8TFTgACwAPBg8bFQWOAQsAAQJJAQAABQQLADgSEUoCSgECAEsAAABEGA4AEAcUDAYKAxFgDAULBgoDEWsMBAsABgAAAAAAAAAACwQKAQsFCgIGAAAAAAAAAAALAQsCCwMRVRIBAgEEAQcBAwEIAQUBBgEAAAAABQAGAAcACAAJAAoACwAMAAEABAACAAMAEQASABMAFAANAA4ADwAQAQIBAQAnAGsAiQEAigEAjQEACnN1aV9zeXN0ZW3YG6Ec6wsGAAAADAEAHAIcPgNakgME7AMKBfYDngMHlAe/DAjTE2AGsxQ2CukUCAzxFKYGDZcbBA+bGwIAMAEcAhACEgIUAhsCLwIzAjQALQAuADEASQBKAAYIAAECBwEAAAIABAEAAQMBDAEAAQULBAAGAwIACAoCAAkEBAAKBQgACwcEAAsIBAALCQQADA0EAA0MDAAAEwABAAAiAgEAACQDAQAAIQMBAAAjAwEAACYEAQAAKwQBAAAlBQEAACoFAQAAHwYBAAAgBwEAACcIAQAAHgkBAAA1CQEAACgDAQAAPwoBAAA9CgEAAD4KAQAARwoBAABACgEAADYKAQAAQgoBAAA4CgEAAEMKAQAAOQoBAABFCgEAADsKAQAARAsBAAA6CwEAAEYKAQAAPAoBAABBCgEAADcKAQAADwwNAAAZDg8AABoOEAAAGA4QAAQOFgECBwQEEScrAgcEBB0nKAIHBAcsGAEBCAgpIyQACw8lDQALExITAAsWARQACx4gAQALHx0BAAsgHgEACyEaAQALIhkBAAsjGgEACyQaAQALJRwBAAsmGwEACycfAQALKBoBAAsqHAEACysbAQALMg8UAAs1IAEACzYhAQALNyEBAAs4IQEACzkhAQALOiIBAAs7IQEACzwhAQALPSEBAAs+IQEACz8hAQALQCEBAAtBIQEAC0IhAQALQyEBAAtEIgEAC0UhAQALRiEBAAtHIQEAC0gTKQAlFSgXJxUlKiYqCAgECggMCwIBCAUDAwgLCAcHCAYAEAcIAAoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgGAgcIAAcIBgMHCAAGCA0DAwcIAAMHCAYEBwgACwMBCAUFBwgGBQcIAAoLAwEIBQsBAQMFBwgGAwcIAAgIBwgGAwcIAAYIDQUDBwgACgIGCAYEBwgACgIKAgYIBgsLAgEIBQsCAQgFBwgAAwMDAwMDAwcIBgELAgEIBQEHCAABBggKAQcICgMIAAgJAwcKCAwLAgEIBQMDCAsIBwcIBgEICQEDAgMICQMHCAQJAAkBAQgAAQkAEAcICgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgGAgcICgcIBgMHCAoGCA0DAwcICgMHCAYEBwgKCwMBCAUFBwgGBQcICgoLAwEIBQsBAQMFBwgGAwcICggIBwgGAwcICgYIDQUDBwgKCgIGCAYEBwgKCgIKAgYIBgEGCAYBBQsHCAoDAwsCAQgFCwIBCAUDAwMDAwcIBgIHCAoICgIHCAQJAAEJAQEICgIDCAoBBwkBB0JhbGFuY2UEQ29pbgZPcHRpb24DU1VJDFN0YWtlU3Vic2lkeQlTdGFrZWRTdWkOU3VpU3lzdGVtU3RhdGUTU3VpU3lzdGVtU3RhdGVJbm5lchVTdWlTeXN0ZW1TdGF0ZUlubmVyVjIQU3lzdGVtUGFyYW1ldGVycwlUeENvbnRleHQDVUlEH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAJVmFsaWRhdG9yA2FkZA1hZHZhbmNlX2Vwb2NoB2JhbGFuY2UKYm9ycm93X211dARjb2luBmNyZWF0ZQ1keW5hbWljX2ZpZWxkB2dlbmVzaXMcZ2VuZXNpc19zeXN0ZW1fc3RhdGVfdmVyc2lvbgJpZBhsb2FkX2lubmVyX21heWJlX3VwZ3JhZGURbG9hZF9zeXN0ZW1fc3RhdGUVbG9hZF9zeXN0ZW1fc3RhdGVfbXV0Bm9iamVjdAZvcHRpb24GcmVtb3ZlEHJlcG9ydF92YWxpZGF0b3IRcmVxdWVzdF9hZGRfc3Rha2UacmVxdWVzdF9hZGRfc3Rha2VfbXVsX2NvaW4VcmVxdWVzdF9hZGRfdmFsaWRhdG9yH3JlcXVlc3RfYWRkX3ZhbGlkYXRvcl9jYW5kaWRhdGUYcmVxdWVzdF9yZW1vdmVfdmFsaWRhdG9yInJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvcl9jYW5kaWRhdGUbcmVxdWVzdF9zZXRfY29tbWlzc2lvbl9yYXRlFXJlcXVlc3Rfc2V0X2dhc19wcmljZRZyZXF1ZXN0X3dpdGhkcmF3X3N0YWtlFHJvdGF0ZV9vcGVyYXRpb25fY2FwBnNlbmRlcidzZXRfY2FuZGlkYXRlX3ZhbGlkYXRvcl9jb21taXNzaW9uX3JhdGUhc2V0X2NhbmRpZGF0ZV92YWxpZGF0b3JfZ2FzX3ByaWNlDHNoYXJlX29iamVjdA1zdGFrZV9zdWJzaWR5DHN0YWtpbmdfcG9vbANzdWkKc3VpX3N5c3RlbRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyFHN5c3RlbV9zdGF0ZV92ZXJzaW9uCHRyYW5zZmVyCnR4X2NvbnRleHQVdW5kb19yZXBvcnRfdmFsaWRhdG9yKnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX25ldHdvcmtfYWRkcmVzcyl1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9uZXR3b3JrX3B1YmtleSZ1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wMnBfYWRkcmVzcyp1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wcmltYXJ5X2FkZHJlc3MqdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcHJvdG9jb2xfcHVia2V5KXVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3dvcmtlcl9hZGRyZXNzKHVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3dvcmtlcl9wdWJrZXkcdXBkYXRlX3ZhbGlkYXRvcl9kZXNjcmlwdGlvbhp1cGRhdGVfdmFsaWRhdG9yX2ltYWdlX3VybBV1cGRhdGVfdmFsaWRhdG9yX25hbWUrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX25ldHdvcmtfYWRkcmVzcyp1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfbmV0d29ya19wdWJrZXkndXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3AycF9hZGRyZXNzK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wcmltYXJ5X2FkZHJlc3MrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleSp1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MpdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3dvcmtlcl9wdWJrZXkcdXBkYXRlX3ZhbGlkYXRvcl9wcm9qZWN0X3VybAh2MV90b192Mgl2YWxpZGF0b3INdmFsaWRhdG9yX2NhcAd2ZXJzaW9uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAAFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFwgESwMAAwAAERcLAQsCCwMLBAsFCwYLBxErDAkRLAwKCwAKChIADAgNCA8ACwoLCTgACwg4AQIBAQQAARMLABEjCwELAgsDCwQLBQsGCwcLCAsJCwoLCwsMCw0LDgsPETECAgEEAAEFCwARIwsBETMCAwEEAAEFCwARIwsBETACBAEEAAEFCwARIwsBETICBQEEAAEGCwARIwsBCwIRNQIGAQQAAQYLABEjCwELAhE5AgcBBAABBgsAESMLAQsCETQCCAEEAAEGCwARIwsBCwIROAIJAQQAAQcLABEjCwELAgsDES4CCgEEAAEICwARIwsBCwILAwsEES8CCwEEAAEGCwARIwsBCwIRNgIMAQQAAQYLABEjCwELAhEtAg0BBAABBgsAESMLAQsCETsCDgEEAAEFCwARIwsBETcCDwEEAAEGCwARIwsBCwIRRQIQAQQAAQYLABEjCwELAhFDAhEBBAABBgsAESMLAQsCEUQCEgEEAAEGCwARIwsBCwIRTQITAQQAAQYLABEjCwELAhFGAhQBBAABBgsAESMLAQsCETwCFQEEAAEGCwARIwsBCwIRSAIWAQQAAQYLABEjCwELAhE+AhcBBAABBgsAESMLAQsCEUkCGAEEAAEGCwARIwsBCwIRPwIZAQQAAQYLABEjCwELAhFLAhoBBAABBgsAESMLAQsCEUECGwEEAAEHCwARIwsBCwILAxFKAhwBBAABBwsAESMLAQsCCwMRQAIdAQQAAQYLABEjCwELAhFMAh4BBAABBgsAESMLAQsCEUICHwEEAAEGCwARIwsBCwIRRwIgAQQAAQYLABEjCwELAhE9AiEAAAAQHQsCESMMCwoKLhEpBwIhBAoFEAsLAQsKAQcAJwsLCwMLBAsACwELBQsGCwcLCAsJCwoRKgIiAAAAAQQLABEkLgIjAAAAAQMLABEkAiQAAAAmLwoAEAEUBgEAAAAAAAAAIQQZCgAPAAoAEAEUOAIRTgwCBgIAAAAAAAAACgAPARUKAA8ACgAQARQLAjgDCgAPAAoAEAEUOAQMAQoBLhE6CwAQARQhBCkFLQsBAQcBJwsBAgAAAAEAFQAMc3Rha2luZ19wb29syB6hHOsLBgAAAAwBABYCFjoDUK8CBP8CJgWlA+ACB4UGkAkIlQ9gBvUPyAEKvRFCDP8R7QsN7B0cD4geBABJATACDwIQAhMCKwIvAkoCTQJOAk8ACAwAAAUHAAAHCAABBAcBAAACAAwAAwEEAQABBAIMAQABBgMHAAYLBAAHBgIACAkMAgcBBAEKCgIAAC0AAQAAPwIDAABABAUAAFQGBwAAUAgJAAAYCgMAAD0LAwAAPAwDAAA7DAMAAFUNCQAADA4DAABBBAUAABUOAwAATA8FAAA2EBEAAEgQBQAARxAFAAAmDxIAACQPEgAARRMIAABGEwMAACoUAwAAIxUSAAA5FhcAADMPBQAANA8FAAAnFhIAAB4YBQAAHxgFAAAiAxcAABIWAwABETQjAQABHDEDAQABIDYzAQMBJTQSAQABKDQSAQABLgMdAQABRDMdAQACLQAgAAMpKAUBAANFMB8BAANTIgUBAANWAx8BAAQdKSoBAAUsLQUABhccAwAGISMRAQgGLQAcAAgOLgMCBwQIETc4AgcECBQ3EgIHBAgtABsCBwQJPiQDAQwJTiQDAQgKGSYFAApDJicAMxokBSoeKR4uATUIJx4rHjQrMBooHiAFJQUiBSMFIQUfBTIaMRoBBwgLAQgABQcIAAsFAQgJBQMHCAsAAwcIAAgCBwgLAQMCBwgACAICAwsFAQgJAQgCAQsFAQgJAgcIAAsFAQgJAgcIAAcICwEHCAAEBwgAAwMDAgcIAAMBBggAAQYIAgEIBwEBAwcIAgMHCAsCBwgCCAICBggCBggCAgYIAAMBCAECBggBAwELCgIDCAECAwgBAQsKAgkACQEBCAgBCwMBCQABCAkBCwUBCQABCAQCCAIDAQYLBQEJAAEGCQACCQAFBgMLBQEICQMLBQEICQUDAQYICwEFAgcLBQEJAAsFAQkAAgsFAQkABwgLAQsGAQkAAQsGAQgJAwMIAQsFAQgJAgMDAwcLCgIJAAkBCQAJAQUDAwgBAwMCBwsFAQkAAwIHCwMBCQAJAAMLBQEICQUDAQkAAQYLAwEJAAIGCAILBQEICQIGCwMBCQAJAAIGCwoCCQAJAQkAAQYJAQMDCAEDA0JhZwdCYWxhbmNlBENvaW4CSUQGT3B0aW9uFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQNTVUkJU3Rha2VkU3VpC1N0YWtpbmdQb29sBVRhYmxlCVR4Q29udGV4dANVSUQVYWN0aXZhdGVfc3Rha2luZ19wb29sEGFjdGl2YXRpb25fZXBvY2gDYWRkA2JhZwdiYWxhbmNlBmJvcnJvdxhjaGVja19iYWxhbmNlX2ludmFyaWFudHMEY29pbghjb250YWlucxdkZWFjdGl2YXRlX3N0YWtpbmdfcG9vbBJkZWFjdGl2YXRpb25fZXBvY2gGZGVsZXRlD2RlcG9zaXRfcmV3YXJkcwVlcG9jaA5leGNoYW5nZV9yYXRlcwxleHRyYV9maWVsZHMEZmlsbAxmcm9tX2JhbGFuY2UOZ2V0X3N1aV9hbW91bnQQZ2V0X3Rva2VuX2Ftb3VudBBnZXRfd2l0aF9kZWZhdWx0AmlkFWluaXRpYWxfZXhjaGFuZ2VfcmF0ZRlpc19lcXVhbF9zdGFraW5nX21ldGFkYXRhC2lzX2luYWN0aXZlB2lzX25vbmUMaXNfcHJlYWN0aXZlFWlzX3ByZWFjdGl2ZV9hdF9lcG9jaAdpc19zb21lBGpvaW4Pam9pbl9zdGFrZWRfc3VpBG1hdGgDbWluA25ldwRub25lBm9iamVjdAZvcHRpb24bcGVuZGluZ19wb29sX3Rva2VuX3dpdGhkcmF3DXBlbmRpbmdfc3Rha2UUcGVuZGluZ19zdGFrZV9hbW91bnQdcGVuZGluZ19zdGFrZV93aXRoZHJhd19hbW91bnQacGVuZGluZ190b3RhbF9zdWlfd2l0aGRyYXcHcG9vbF9pZBFwb29sX3Rva2VuX2Ftb3VudBJwb29sX3Rva2VuX2JhbGFuY2UhcG9vbF90b2tlbl9leGNoYW5nZV9yYXRlX2F0X2Vwb2NoCXByaW5jaXBhbBVwcm9jZXNzX3BlbmRpbmdfc3Rha2UecHJvY2Vzc19wZW5kaW5nX3N0YWtlX3dpdGhkcmF3JHByb2Nlc3NfcGVuZGluZ19zdGFrZXNfYW5kX3dpdGhkcmF3cw9wdWJsaWNfdHJhbnNmZXIRcmVxdWVzdF9hZGRfc3Rha2UWcmVxdWVzdF93aXRoZHJhd19zdGFrZSByZXF1ZXN0X3dpdGhkcmF3X3N0YWtlX3ByZWFjdGl2ZQxyZXdhcmRzX3Bvb2wGc2VuZGVyBHNvbWUFc3BsaXQQc3BsaXRfc3Rha2VkX3N1aRZzdGFrZV9hY3RpdmF0aW9uX2Vwb2NoEXN0YWtlZF9zdWlfYW1vdW50DHN0YWtpbmdfcG9vbANzdWkKc3VpX2Ftb3VudAtzdWlfYmFsYW5jZQV0YWJsZQh0cmFuc2Zlcgp0eF9jb250ZXh0EXVud3JhcF9zdGFrZWRfc3VpCXZhbGlkYXRvcg12YWxpZGF0b3Jfc2V0BXZhbHVlF3dpdGhkcmF3X2Zyb21fcHJpbmNpcGFsEHdpdGhkcmF3X3Jld2FyZHMEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAMqaOwAAAAADCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAMIBQAAAAAAAAADCAYAAAAAAAAAAwgHAAAAAAAAAAMICAAAAAAAAAADCAkAAAAAAAAAAwgKAAAAAAAAAAMICwAAAAAAAAADCAwAAAAAAAAAAwgNAAAAAAAAAAMIDgAAAAAAAAADCA8AAAAAAAAAAwgQAAAAAAAAAAMIEQAAAAAAAAADCBIAAAAAAAAAAAILIQgIDQsDAQMWCwMBA0wDQgsFAQgJOAMaCwoCAwgBMgM1AzEDGwgEAQICSwM3AwICBCEICDYIB0cDOgsFAQgJAAMAABkSCgA4AAwBCgARLzgBOAEGAAAAAAAAAAA4AgYAAAAAAAAAAAsBBgAAAAAAAAAABgAAAAAAAAAABgAAAAAAAAAACwARJhIAAgEDAAAhLw4BOAMMBgoALhESIAQJBQ8LAAELBAEHCycKBgYAAAAAAAAAACQEFAUaCwABCwQBBxInCwQRLwoALjgECwMLARICDAUKABAAFAsGFgsADwAVCwULAjgFAgIDAAAlPQoACwERAwwEDAMKAi4RNwwHDgQ4AwwFCgAKBQoDCgIuETYRCQwGCwUOBjgDFgwICgAQARQKCBYKAA8BFQoAEAIUCwMWCgAPAhUKAC4REgQwCwARBwUyCwABDQQLBjgGAQsECwI4BwsHOAgLCAIDAwAALB8OARADFAoALjgEIQQJBQ0LAAEHAicLAA4BEAQUDAIuCwIRFwwDCwERBAwEDgMOBDgDERwLBAIEAAAACQgLABMCDAEBAREtCwECBQMAAAMPCgAQBRQOATgDFgoADwUVCwAPBgsBOAYBAgYDAAAtHAsBLhE2BgEAAAAAAAAAFgwDCgARBwoAEQgKAA8HCgMKABAFFAoAEAgUEgE4CQsACwMMAi4LAhEeAgcAAAADHQoAEAUUCgAQARQXCgAPBRUKABAIFAoAEAIUFwoADwgVBgAAAAAAAAAACgAPARUGAAAAAAAAAAALAA8CFQIIAwAAFx8KABAFFAoAEAgUEgEMAQoAEAUUCgAQABQWCgAPBRUOAQoAEAUUERwKAA8IFQYAAAAAAAAAAAsADwAVAgkAAAAvIQoACwMMBC4LBBEXDAYOBgsCERsMCAoICgEmBBQLCAsBFwwFBRYGAAAAAAAAAAAMBQsFCgAQBjgDESwMBwsADwYLBzgKAgoDAAADHQoADwcKAREdOAkKAC4REQQKBQ4LAAEHDycKAC4REiAEFAUYCwABBxEnCwAPCQsBOAsCCwMAADI7DgEQAxQKAC44BCEECQUPCwABCwIBBwInCgAuEREEFAUaCwABCwIBBxAnCgIuETcMBAsBEQQMAw4DOAMMBQoAEAUUCgUXCgAPBRUKABAIFAoFFwsADwgVCwMLAjgHCwQ4CAsFAgwDAAADEAoALhESIAQGBQoLAAEHDCcLATgMCwAPChUCDQEAAAMECwAQBRQCDgEAAAMECwAQAxQCDwEAAAMECwAQCzgDAhABAAADBAsAEAQUAhEBAAADBAsAEAk4DQISAQAAAwQLABAKOA4CEwEAAAMOCwIRLwoAEAMUCgAQBBQLAA8LCwE4ChICAhQBBAAFMAoAEAs4AwwDCgEKAyUECQUPCwABCwIBBwQnCwMKARcHACYEFgUcCwABCwIBBxMnCgEHACYEIQUnCwABCwIBBxMnCwALAQoCERMLAi4RNzgFAhUBBAA1GAoADgEMAi4LAhEWBAgFDAsAAQcNJwsBEwIMAwEBES0LAA8LCwM4BgECFgEAABIZCgAQAxQKARADFCEEEQsAEAQUCwEQBBQhDAIFFwsAAQsBAQkMAgsCAhcBAAAtLQoACgERGgQICwABER0CCgAQCgoBOA8LAREsDAMKABAJOBAUDAIKAwoCJgQpBRkKABAHCgM4EQQkCwAQBwsDOBIUAgsDBgEAAAAAAAAAFwwDBRQLAAERHQIYAQAAAwQLABAAFAIZAQAAAwQLABABFAIaAAAAEhEKABERBAgLAAEIDAIFDwsAEAk4EBQLASQMAgsCAhsAAAASIwoAEAwUBgAAAAAAAAAAIQQJCAwCBQ8KABANFAYAAAAAAAAAACEMAgsCBBULAAELAQIKABAMFDULATUYCwAQDRQ1GjQCHAAAABIjCgAQDBQGAAAAAAAAAAAhBAkIDAIFDwoAEA0UBgAAAAAAAAAAIQwCCwIEFQsAAQsBAgoAEA0UNQsBNRgLABAMFDUaNAIdAAAAAwQGAAAAAAAAAAAGAAAAAAAAAAASAQIeAAAAORYKAAsBERcMAw4DCgAQBRQRHAwECwAQCBQMAgsECwIhBBMFFQcKJwIABwAIAAkCAQICAAMABAAGAAUAAQACAgMBAAEBAFEAUgAMc3RvcmFnZV9mdW5ktQShHOsLBgAAAAsBAAYCBg4DFCwEQAgFSEkHkQGyAQjDAkAKgwMPDJIDaw39AwQPgQQCAAkBBAEKAAIEAAEABAEAAQIBAgAABgABAAADAgAAAA0DBAAADAMEAAEFCAQBAAEICQcBAAEOCgQBAAEPBQcBAAcGBAYFBgYGAQsBAQgCAQgABgcIAAsBAQgCCwEBCAILAQEIAgMDAQYIAAEDAAEIAgELAQEJAAIHCwEBCQALAQEJAAIHCwEBCQADAQYLAQEJAAdCYWxhbmNlA1NVSQtTdG9yYWdlRnVuZA1hZHZhbmNlX2Vwb2NoB2JhbGFuY2UEam9pbgNuZXcWbm9uX3JlZnVuZGFibGVfYmFsYW5jZQVzcGxpdAxzdG9yYWdlX2Z1bmQDc3VpFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXINdG90YWxfYmFsYW5jZRx0b3RhbF9vYmplY3Rfc3RvcmFnZV9yZWJhdGVzBXZhbHVlBHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAICDQsBAQgCBwsBAQgCAAMAAAUEOAALABIAAgEDAAAAHgoADwALAjgBAQoADwALAzgBAQoADwELATgBAQoADwELBTgCDAYKAA8ACwY4AQELAA8BCwQ4AgICAQAABQQLABABOAMCAwEAAAUICgAQATgDCwAQADgDFgIAAQAAAAsADHZvdGluZ19wb3dlcpcNoRzrCwYAAAAMAQAIAggMAxRXBGsEBW+GAQf1AbACCKUEYAaFBUYKywUQDNsF/gYN2QwED90MAgAWARUCCQASAAECAAACAgADAAQAAA0AAQAABgIDAAAPBAUAAAcGAQAAAwcBAAARCAEAAAQEAQAAEAEFAAAMAQUAAQcRAQEAAQgTFAEAAgULBQACCgsFAAILCwUAAw0VAQADDw4FAAMWDgUACQ0KDQEHCggCAAIGCggCAwIKCAEDAQYKCAIBAwIHCggBCAEDBwoIAQMDAgcKCAIKCAEEAwoIAQMDAQgCAgMDCAMIAQMKCAEDAwMDAQgBAQYIAgMDAwMEAwEDAwMHCgkACQADBwEDAwMDAwcIAQEGCgkAAQECBwgCAwwDAwMDAwMDAwMGCAIGCAIDCVZhbGlkYXRvcg9Wb3RpbmdQb3dlckluZm8RVm90aW5nUG93ZXJJbmZvVjITYWRqdXN0X3ZvdGluZ19wb3dlchBjaGVja19pbnZhcmlhbnRzE2RpdmlkZV9hbmRfcm91bmRfdXAWaW5pdF92b3RpbmdfcG93ZXJfaW5mbwZpbnNlcnQIaXNfZW1wdHkEbWF0aANtYXgDbWluEHF1b3J1bV90aHJlc2hvbGQQc2V0X3ZvdGluZ19wb3dlcgVzdGFrZQt0b3RhbF9zdGFrZRJ0b3RhbF92b3RpbmdfcG93ZXITdXBkYXRlX3ZvdGluZ19wb3dlcgl2YWxpZGF0b3IPdmFsaWRhdG9yX2luZGV4DXZhbGlkYXRvcl9zZXQGdmVjdG9yDHZvdGluZ19wb3dlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIECcAAAAAAAADCAsaAAAAAAAAAwjoAwAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAAAAgITAxYDAQIDEwMWAw4DAAMAAAkdBwAHAgcACgAuQQoRCxEMEQ0MBAoACgQMAS4LAREBDAMMAg0CCwQLAxEECgALAhEFCwAuEQYCAQAAAAw6CgARAgwIBgAAAAAAAAAADAIKAEEKDAQGAAAAAAAAAAAMB0ANAAAAAAAAAAAMBQoCCgQjBDMFEQoACgJCChEPDAYKBjUHADUYCgg1GjQKARENDAkKAgoJCwYSAQwDDQULAxEDCwcLCRYMBwsCBgEAAAAAAAAAFgwCBQwLAAELBQcACwcXAgIAAAAPHAYAAAAAAAAAAAwBCgBBCgwCBgAAAAAAAAAADAMKAQoCIwQYBQwLAwoACgFCChEPFgwDCwEGAQAAAAAAAAAWDAEFBwsAAQsDAgMAAAAQJwYAAAAAAAAAAAwECgAuQQ0MBQoECgUjBBkFCwoACgQMAi4LAkINEAAUDgEQABQkDAMFGwkMAwsDBCILBAYBAAAAAAAAABYMBAUGCwALAQsEOAACBAAAABJUBgAAAAAAAAAADAUKAC5BDQwGCgUKBiMEEAULCgIGAAAAAAAAAAAkDAMFEgkMAwsDBEoKAAoFQw0MCQoCCgYKBRcRCwwHCgEKCRABFAsHFhENDAgKAgsICgkQARQXEQ0MBAoJEAEUCgQWCgkPARULCRABFAoBJQQ9BUELAAEHBScLAgsEFwwCCwUGAQAAAAAAAAAWDAUFBgsAAQsCBgAAAAAAAAAAIQRRBVMHAycCBQAAAAsWDgE4ASAEEQUFDQFFDRMBAQwDDAIKAAsCQwoLAxEOBQALAAELAUYNAAAAAAAAAAACBgAAABZ3BgAAAAAAAAAADAMKAEEKDAQGAAAAAAAAAAAMCQoDCgQjBCMFDAoACgNCChEQDAwKDAYAAAAAAAAAACQEFgUaCwABBwYnCwkLDBYMCQsDBgEAAAAAAAAAFgwDBQcLCQcAIQQoBSwLAAEHAycGAAAAAAAAAAAMAQoBCgQjBHQFMwoBBgEAAAAAAAAAFgwCCgIKBCMEbwU8CgAKAUIKDAoKAAoCQgoMCwoKEQ8MBwoLEQ8MCAsKERAMBQsLERAMBgoHCggkBF0KBQoGJgRZBV0LAAEHBCcLBwsIIwRqCwULBiUEZgVqCwABBwQnCwIGAQAAAAAAAAAWDAIFNwsBBgEAAAAAAAAAFgwBBS4LAAECBwEAAAECBwACCAEAAAECBwECAQIBAQAUAA1zdGFrZV9zdWJzaWR5rgahHOsLBgAAAAwBAAwCDBYDIiUERwQFS0oHlQGwAgjFA0AGhQQcCqEEFAy1BLQBDekFCg/zBQQAEgEGAQcBDgEVARcAAwQAAQAMAAIBBAEAAQQCAgAFBAIAAAgAAQAABQIDAAAKBAUAARAHCAACEQ0OAQACGAsFAQADDwwFAAUKBAoFCwIBCAMDAw0HCAQBCAABBwgAAQsCAQgDAQYIAAEDAAEHCAQBCAEDBAsCAQgDAwEIAwEGCwIBCQACAwMCBwsCAQkAAwELAgEJAANCYWcHQmFsYW5jZQNTVUkMU3Rha2VTdWJzaWR5CVR4Q29udGV4dA1hZHZhbmNlX2Vwb2NoA2JhZwdiYWxhbmNlBmNyZWF0ZRtjdXJyZW50X2Rpc3RyaWJ1dGlvbl9hbW91bnQcY3VycmVudF9lcG9jaF9zdWJzaWR5X2Ftb3VudBRkaXN0cmlidXRpb25fY291bnRlcgxleHRyYV9maWVsZHMHZ2VuZXNpcwRtYXRoA21pbgNuZXcFc3BsaXQNc3Rha2Vfc3Vic2lkeRtzdGFrZV9zdWJzaWR5X2RlY3JlYXNlX3JhdGUbc3Rha2Vfc3Vic2lkeV9wZXJpb2RfbGVuZ3RoA3N1aRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyCnR4X2NvbnRleHQFdmFsdWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBBAQJwAAAAAAAAAAAAAAAAAAAwgAAAAAAAAAAAACBgcLAgEIAwsDCQMUAxMNDAgBAAMAAAYTCgMHAEslBAYFCgsEAQcBJwsABgAAAAAAAAAACwELAgsDCwQRAxIAAgEDAAAJOQoAEAAUCgAQATgAEQYMAwoADwELAzgBDAIKABACFAYBAAAAAAAAABYKAA8CFQoAEAIUCgAQAxQZBgAAAAAAAAAAIQQ1CgAQABQ1CgAQBBQ1GAcAGgwBCgAQABQLATQXCwAPABUFNwsAAQsCAgIBAAAGCAoAEAAUCwAQATgAEQYCAAIAAAABAAMABAANABYADXZhbGlkYXRvcl9jYXCBBqEc6wsGAAAADAEACAIIFAMcKgRGBAVKNgeAAeICCOIDQAaiBCIKxAQNDNEEcA3BBQQPxQUGABIBCgEOAQ8AAwwAAAQCAAEABwABAgQAAwECAAAQAAEAABQCAQAACQMEAAAIAAUAAQYNBAEIAQcKCwACCw4GAQwDDAgJAAQMBgwBBggAAQYFAQYIAQIFBwgEAQgCAQgBAAQBCAAIAgUBBggEAQUBBwgEAQgDAQgAAQYJAAIJAAUCSUQJVHhDb250ZXh0A1VJRB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwFVZhbGlkYXRvck9wZXJhdGlvbkNhcBxhdXRob3JpemVyX3ZhbGlkYXRvcl9hZGRyZXNzAmlkA25ldxNuZXdfZnJvbV91bnZlcmlmaWVkM25ld191bnZlcmlmaWVkX3ZhbGlkYXRvcl9vcGVyYXRpb25fY2FwX2FuZF90cmFuc2ZlcgZvYmplY3QPcHVibGljX3RyYW5zZmVyBnNlbmRlchZzdWlfc3lzdGVtX3N0YXRlX2lubmVyCHRyYW5zZmVyCnR4X2NvbnRleHQgdW52ZXJpZmllZF9vcGVyYXRpb25fY2FwX2FkZHJlc3MJdmFsaWRhdG9yDXZhbGlkYXRvcl9jYXANdmFsaWRhdG9yX3NldB52ZXJpZmllZF9vcGVyYXRpb25fY2FwX2FkZHJlc3MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgYIAwUFAQIBBQUAAwAABgMLABAAAgEDAAAGAwsAEAECAgMAAAcjCgEuEQcMBQoFBwAhBAsIDAIFDwsFCgAhDAILAgQSBRYLAQEGAAAAAAAAAAAnCwERBQoAEgAMAw4DOAAMBAsDCwA4AQsEAgMDAAAGBQsAEAAUEgECAAEBAAANABEAEwANdmFsaWRhdG9yX3NldLZQoRzrCwYAAAAMAQAzAjNwA6MBhgYEqQeFAQWuCNIJB4AStxcItylgBpcqwwEK2iuNAQznLPsiDeJPEA/yTwUAnwEBZwGnAQIeAh8COQJlAnECjQECkQECkgECmAECpQECpgEAiQEAmwEAngEAowEAqgEAEwQAAA4DAAAPAwAAEAMAABEDAAEEBwEAAAMADAAEAQQBAAEGAwcABwIGAQIABwYGAQIACAcCAAkJDAIHAQQBCgoEAQQBCwsCAAwVBwIBAAAADRYHAQMADgUHAA4ICAAPDQQAEAwMABASAgARFAQAAGAAAQAAfAIDAAB+BAMAAHsFAwAAHAYDAAB9BAMAAHoHAwAAgAEIAwAAfwkDAAAbCgMAAJoBCwMAADQMAwAALw0OAACVAQ0OAACiAQ8OAACgAQ8OAAChAQ8QAACLAQ0RAABjDQ4AAFEPEgAAVAYSAABTExIAACsTDgAAVQYSAAAqFA4AAEQVFgAAPBcYAAA9GRgAAEcaGwAASBwWAABBHRYAAEseFgAASR8WAABKHxYAAEwXIAAAQiEgAABDDyAAAEYPIAAAqQEiIwAAciQDAAB1JQMAACMmAwAAdCcDAACFASgDAABzKQMAACIqDgAAGisDAAAmLC0AACcuLwAAKDAxAAAlMjEAADMzAwAANjQDAACQARoOAAAYDSoAAFoPEgAAVzUSAAExb1EBAAE7UFEBAAFZTxIBAAFkA28BAAGEAVFvAQACKVISAQACVn0SAQACeWFRAQADYDhCAAQylAEDAQAEXJUBDgEABIYBkwGUAQEABKQBVA4BAAU1UQMBAwZNbhABCAdgZ2gBAgdhZWYBAgdwaWUBAgkZPAMCBwQJIERXAgcECSFJWQIHBAkpRBICBwQJYDg5AgcECXlJSgIHBAogbW4BBAohcnMBBAo3OD0BBApWahIBBApeag4BBApvhwFRAQQKdk0DAQQLOEgOAAuBAUg7AAwpXRICAQAMNwNBAgEADEBdVwIBAAxFXlkCAQAMT2ADAgEADFaCARICAQAMXYIBgwECAQAMbo4BXwIBAAx5Xl8CAQAMgwGCAQ4CAQANKYQBEgEDDVCPAYMBAQMNVoYBEgEDDXmFAQMBAw5qVhAADxdLAwAPGhYDAA8kIA4ADy1LAwAPLpYBAwAPNBYDAA8+IA4AD1JsEgAPWCASAA9mIHsAD22YAZkBAA9zigEDAA96VQMAD39LAwAPgAFYAwAPiAEgDgAPigEgEAAPjgEgOwAPlgEgDgAPqgEgDgAQYnkjABCZAXl1ABCoAXR1ABEsRUYAETBGOgARX1oWABJ3Aw4AEoIBKwMAEpcBAw4ATzdLN1M6Tz5PP1tATj9LP1A/UDdLPlc6Ow46Dj4ORVNON0w3Tj5NPlpAYkBdQF5AQDpJDkgOSg5VOlE6TT89DjwOOQ5SOkd6Pw5Gf1qBAWKBAWCBAV2BAWQ7ZztmO1Q6VjpGiAFbYl5iX4EBYYEBZTtjYlpiXGJEU0NTQlNcgQE+O0aaAQIKCBMHCA4BCAADBwgACBMHCA4AAgcIAAcIDgMHCAADBwgOAgYIAAYIEwQHCAAFCwcBCAsHCA4DBwgACBIHCA4DBwgAAwYIDgkHCAAHCwcBCAsHCwcBCAsHCw8CBQsQAQUDAwMDBwgOBgcIAAMDAwcLDwIFCxABBQcIDgEHCAABBggAAQMCBggABQEICAEGCwwCCAgFAQECBgoIEwYIEwIGCw0BCBMGCBMCBwgABQEHCBMCBgoIEwUBCwUBAwIGCw0BCBMFAgYKCBMGCgUBCgMCBwoIEwUDBwgABQEDBwgABggVAQIHCAAGCA4BBggTAwcIAAUCAwcIAAYIFAIBCBUDBwgABwsPAgULEAEFBwgOBQcIAAgTBwsPAgULEAEFAQcIDgIHCw8CBQsQAQUFAgcIAAMBBwoDAgcKCBMHCA4BBgoIEwEHCggTBAoDAwYKAwYKAwQDCw8CAwMDCw8CAwMCBggACw8CBQsQAQUBCgUEBgoIEwMDAwIKAwoDCQYKCBMDAwoDCgMDCw8CAwMDCw8CAwMGBwoIEwYKAwYKAwcLBwEICwcLBwEICwcIDgYDBgoIEwYKAwYKAwYLDwIFCxABBQYKBQIGCAAICAYDAwsMAggIBQMGCBMIAAIICAUBBwgOAQsMAgkACQEBCBMBBQMHCwwCCQAJAQkACQEBCw0BCQACCAgIFgIFCBYCBQMBCw8CCQAJAQEIBgQGCBMGCBMBBQIGCwwCCQAJAQkAAggTBwgOAQgWAwgICBMFAQYIDgIHCwwCCQAJAQkAAQkBAgcIEwMFBggTBggTAQgTBQIHCw0BCQAJAAMFAwsFAQMBBgsFAQkAAQcLBQEJAAEJAAIGCgkABgkAAQgLAQYLBwEJAAQHCBMLBwEICwUHCA4BBggSAQYJAQMHCBMIEgcIDgEHCQEBBwgWDgsPAgULEAEFBgoFCgMKAwsPAgMDCw8CAwMDCgUDAwMDCgMKAwgDAwcDAwgTCBMFBggTAgYLDwIJAAkBBgkAAgcLDwIJAAkBBgkAAgkACQEDBwsPAgkACQEJAAkBAgcKCQADAgMDCgoLCQEDAwMLCgEDAwMDAwYIEwYKCBMBCwkBAwIDCQABCwkBCQABCgsJAQkAAQsKAQkAAQcLCgEJAAEGCw0BCQADAwMDAgYIEwYIEwIGCw0BCQADAQYJAAELBQEJAAUFAwsFAQMDCgMEAwMLBQEDCwUBAwIHCw0BCQADAQcJAAEGCBUBBgUCAwsFAQMGAQEDAwsFAQMLBQEDBQUGCBMICAUGCBMBBggUAQgUAQYICAIDCBMBBgoJAAMDBQgIAQgEBwYFBgUDAwYFCgUHCxABBQIFCxABBQEGCw8CCQAJAQEKCQACBgsQAQkABgkAAgcLEAEJAAYJAAEGCxABCQABBwsNAQkAAQgDBgMDAwMDAwIHCBMHCA4EAwMDBggTBwsPAgMDCw8CAwMEBAMDAwUKBQYKCBMLEAEFCgUFAQcLDwIJAAkBAQsQAQkABgMDBAoDCgMDEQMDAwoDAwoDAwQDAwMDAwMDAwQIAwMLBwEICwMHCBMFBAsHAQgLAgcLBwEJAAMBCwcBCQACBwsHAQkACwcBCQACBwgTCwcBCAsICgUDAwMDCgUGCBMFAgYIEwMBCBEBCAIDQmFnB0JhbGFuY2UFRW50cnkCSUQGT3B0aW9uFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQ1Qcmlvcml0eVF1ZXVlA1NVSQlTdGFrZWRTdWkFVGFibGUIVGFibGVWZWMJVHhDb250ZXh0H1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAJVmFsaWRhdG9yF1ZhbGlkYXRvckVwb2NoSW5mb0V2ZW50GVZhbGlkYXRvckVwb2NoSW5mb0V2ZW50VjISVmFsaWRhdG9ySm9pbkV2ZW50E1ZhbGlkYXRvckxlYXZlRXZlbnQVVmFsaWRhdG9yT3BlcmF0aW9uQ2FwDFZhbGlkYXRvclNldBBWYWxpZGF0b3JXcmFwcGVyBlZlY01hcAZWZWNTZXQIYWN0aXZhdGURYWN0aXZlX3ZhbGlkYXRvcnMDYWRkGmFkanVzdF9zdGFrZV9hbmRfZ2FzX3ByaWNlDWFkdmFuY2VfZXBvY2gmYXNzZXJ0X25vX3BlbmRpbmdfb3JfYWN0aXZlX2R1cGxpY2F0ZXMSYXRfcmlza192YWxpZGF0b3JzA2JhZwdiYWxhbmNlBmJvcnJvdwpib3Jyb3dfbXV0FmNhbGN1bGF0ZV90b3RhbF9zdGFrZXMmY2xlYW5fcmVwb3J0X3JlY29yZHNfbGVhdmluZ192YWxpZGF0b3IPY29tbWlzc2lvbl9yYXRlJGNvbXB1dGVfYWRqdXN0ZWRfcmV3YXJkX2Rpc3RyaWJ1dGlvbhpjb21wdXRlX3Jld2FyZF9hZGp1c3RtZW50cxpjb21wdXRlX3NsYXNoZWRfdmFsaWRhdG9ycyZjb21wdXRlX3VuYWRqdXN0ZWRfcmV3YXJkX2Rpc3RyaWJ1dGlvbghjb250YWlucxljb3VudF9kdXBsaWNhdGVzX3RhYmxldmVjFGNvdW50X2R1cGxpY2F0ZXNfdmVjCWNyZWF0ZV92MQpkZWFjdGl2YXRlFWRlcG9zaXRfc3Rha2VfcmV3YXJkcxpkZXJpdmVfcmVmZXJlbmNlX2dhc19wcmljZQdkZXN0cm95DGRlc3Ryb3lfc29tZQxkZXN0cm95X3plcm8RZGlzdHJpYnV0ZV9yZXdhcmQaZWZmZWN0dWF0ZV9zdGFnZWRfbWV0YWRhdGEEZW1pdBtlbWl0X3ZhbGlkYXRvcl9lcG9jaF9ldmVudHMFZW1wdHkFZXBvY2gFZXZlbnQMZXh0cmFfZmllbGRzB2V4dHJhY3QOZmluZF92YWxpZGF0b3IdZmluZF92YWxpZGF0b3JfZnJvbV90YWJsZV92ZWMJZ2FzX3ByaWNlB2dlbmVzaXMDZ2V0MGdldF9hY3RpdmVfb3JfcGVuZGluZ19vcl9jYW5kaWRhdGVfdmFsaWRhdG9yX211dDBnZXRfYWN0aXZlX29yX3BlbmRpbmdfb3JfY2FuZGlkYXRlX3ZhbGlkYXRvcl9yZWYYZ2V0X2FjdGl2ZV92YWxpZGF0b3JfcmVmJWdldF9jYW5kaWRhdGVfb3JfYWN0aXZlX3ZhbGlkYXRvcl9tdXQHZ2V0X211dBlnZXRfcGVuZGluZ192YWxpZGF0b3JfcmVmFWdldF92YWxpZGF0b3JfaW5kaWNlcxFnZXRfdmFsaWRhdG9yX211dBpnZXRfdmFsaWRhdG9yX211dF93aXRoX2N0eC9nZXRfdmFsaWRhdG9yX211dF93aXRoX2N0eF9pbmNsdWRpbmdfY2FuZGlkYXRlcyNnZXRfdmFsaWRhdG9yX211dF93aXRoX3ZlcmlmaWVkX2NhcBFnZXRfdmFsaWRhdG9yX3JlZgJpZBNpbmFjdGl2ZV92YWxpZGF0b3JzBmluc2VydAlpbnRvX2tleXMiaXNfYWN0aXZlX3ZhbGlkYXRvcl9ieV9zdWlfYWRkcmVzcwxpc19kdXBsaWNhdGUWaXNfZHVwbGljYXRlX3ZhbGlkYXRvciJpc19kdXBsaWNhdGVfd2l0aF9hY3RpdmVfdmFsaWRhdG9yI2lzX2R1cGxpY2F0ZV93aXRoX3BlbmRpbmdfdmFsaWRhdG9yCGlzX2VtcHR5FWlzX2luYWN0aXZlX3ZhbGlkYXRvcgxpc19wcmVhY3RpdmUHaXNfc29tZRZpc192YWxpZGF0b3JfY2FuZGlkYXRlDGlzX3ZvbHVudGFyeQRqb2luBGtleXMGbGVuZ3RoHGxvYWRfdmFsaWRhdG9yX21heWJlX3VwZ3JhZGUDbmV3CW5ld19lbnRyeRNuZXdfZnJvbV91bnZlcmlmaWVkGm5leHRfZXBvY2hfdmFsaWRhdG9yX2NvdW50BG5vbmUGb2JqZWN0EG9wZXJhdGlvbl9jYXBfaWQGb3B0aW9uGXBlbmRpbmdfYWN0aXZlX3ZhbGlkYXRvcnMQcGVuZGluZ19yZW1vdmFscwdwb29sX2lkE3Bvb2xfc3Rha2luZ19yZXdhcmQYcG9vbF90b2tlbl9leGNoYW5nZV9yYXRlIXBvb2xfdG9rZW5fZXhjaGFuZ2VfcmF0ZV9hdF9lcG9jaANwb3AIcG9wX2JhY2sHcG9wX21heA5wcmlvcml0eV9xdWV1ZRhwcm9jZXNzX3BlbmRpbmdfcmVtb3ZhbHMkcHJvY2Vzc19wZW5kaW5nX3N0YWtlc19hbmRfd2l0aGRyYXdzGnByb2Nlc3NfcGVuZGluZ192YWxpZGF0b3JzG3Byb2Nlc3NfdmFsaWRhdG9yX2RlcGFydHVyZQlwdXNoX2JhY2sQcXVvcnVtX3RocmVzaG9sZBpyZWZlcmVuY2VfZ2FzX3N1cnZleV9xdW90ZQZyZW1vdmURcmVxdWVzdF9hZGRfc3Rha2UVcmVxdWVzdF9hZGRfdmFsaWRhdG9yH3JlcXVlc3RfYWRkX3ZhbGlkYXRvcl9jYW5kaWRhdGUYcmVxdWVzdF9yZW1vdmVfdmFsaWRhdG9yInJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvcl9jYW5kaWRhdGUbcmVxdWVzdF9zZXRfY29tbWlzc2lvbl9yYXRlFnJlcXVlc3Rfd2l0aGRyYXdfc3Rha2UGc2VuZGVyEHNldF92b3RpbmdfcG93ZXIEc2l6ZQRzb21lEXNvcnRfcmVtb3ZhbF9saXN0BXNwbGl0BXN0YWtlDHN0YWtlX2Ftb3VudAxzdGFraW5nX3Bvb2wPc3Rha2luZ19wb29sX2lkFXN0YWtpbmdfcG9vbF9tYXBwaW5ncxtzdG9yYWdlX2Z1bmRfc3Rha2luZ19yZXdhcmQDc3VpC3N1aV9hZGRyZXNzFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIdc3VtX3ZvdGluZ19wb3dlcl9ieV9hZGRyZXNzZXMFdGFibGUJdGFibGVfdmVjGnRhbGx5aW5nX3J1bGVfZ2xvYmFsX3Njb3JlF3RhbGx5aW5nX3J1bGVfcmVwb3J0ZXJzC3RvdGFsX3N0YWtlEnRvdGFsX3N0YWtlX2Ftb3VudBJ0b3RhbF92b3RpbmdfcG93ZXIKdHhfY29udGV4dCB1bnZlcmlmaWVkX29wZXJhdGlvbl9jYXBfYWRkcmVzcyd1cGRhdGVfYW5kX3Byb2Nlc3NfbG93X3N0YWtlX2RlcGFydHVyZXMJdmFsaWRhdG9yEXZhbGlkYXRvcl9hZGRyZXNzFHZhbGlkYXRvcl9jYW5kaWRhdGVzDXZhbGlkYXRvcl9jYXANdmFsaWRhdG9yX3NldBZ2YWxpZGF0b3Jfc3Rha2VfYW1vdW50GXZhbGlkYXRvcl9zdGFraW5nX3Bvb2xfaWQcdmFsaWRhdG9yX3RvdGFsX3N0YWtlX2Ftb3VudBF2YWxpZGF0b3Jfd3JhcHBlcgV2YWx1ZQd2ZWNfbWFwB3ZlY19zZXQGdmVjdG9yHnZlcmlmaWVkX29wZXJhdGlvbl9jYXBfYWRkcmVzcwp2ZXJpZnlfY2FwDHZvdGluZ19wb3dlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIBAQIBAgIBAwQQECcAAAAAAAAAAAAAAAAAAAMIAMqaOwAAAAADCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAMIBQAAAAAAAAADCAYAAAAAAAAAAwgHAAAAAAAAAAMICAAAAAAAAAADCAkAAAAAAAAAAwgKAAAAAAAAAAMICwAAAAAAAAADCAwAAAAAAAAAAwgNAAAAAAAAAAMIZQAAAAAAAAAKAwEACgUBAAACCZUBAxgKCBNoCw0BCBNpCgOLAQsMAggIBU4LDAIICAgWnQELDAIFCBYdCw8CBQM6CAYBAgo4A5wBBXgDhwEDJANrA4wBA2wIEZQBCgWTAQMCAgs4A5wBBXgDhwEDqgEDJANrA4wBA2wIEZQBCgWTAQMDAgM4A5wBBYoBCAgEAgQ4A5wBBYoBCAhbAQADAAA2Mw4AES0MBQoBOAAMBA4AQToMAwYAAAAAAAAAAAwCCgIKAyMEHwUQDgAKAkI6DAYNBAoGEXkLBhF6OAELAgYBAAAAAAAAABYMAgULCwULAAoBOAJADgAAAAAAAAAACwQKATgDCgE4BDgFCwERQRIADAcNBw8AEYQBCwcCAQMAAENFCgAOAQwDLgsDERQgBBEKAA4BDAQuCwQRFyAMBQUTCQwFCwUEFgUcCwABCwIBBwcnDgERegwGCgAQAQoGOAYgBCYFLAsAAQsCAQcLJw4BEXEEMAU2CwABCwIBBwwnCgAPAg4BEXkLBjgBCwAPAQ4BEXoLAQsCEYABOAcCAgMAAEc1CgEuEVkMBAoAEAEKBDgGBAoFEAsAAQsBAQcNJwoADwELBDgIEYEBDAMOAxFxBBoFIAsAAQsBAQcMJw4DEXkMAgoADwIKAjgJAQ0DCgEuEVgRbAsADwMLAgsDCwERgAE4CgIDAwAATEULAi4RWQwHCgAQAQoHOAYECgUOCwABBw0nCgAPAQsHOAgRgQEMBgoADgYMAy4LAxEUIAQlCgAOBgwELgsEERcgDAUFJwkMBQsFBCoFLgsAAQcHJw4GEXEEMgU2CwABBwwnDgYRewsBJgQ8BUALAAEHCicLAA8ECwY4CwIEAwAAAxAKABAACgERFgsAEAQLAREYFgYBAAAAAAAAACEEDQUPBwcnAgUDAABOJAsBLhFZDAIKABAACwIRGgwEDgQ4DAQNBRELAAEHCScNBDgNDAMKABAFDgM4DiAEGwUfCwABBxAnCwAPBQsDRA4CBgMAAAMWDgI4DwcEJgQGBQwLAAELAwEHDycLAAsBERkLAgoDLhFZCwMRdQIHAwAANysOARFoDAMKABACCgM4EAQWCgAQAg4BEWg4ERQMBAsACwQRGQsBCwIRdwUqCgAQAwoDOBIEHAUiCwABCwIBBwgnCwAPAwsDOBMRggELAQsCEXcCCAMAADsKCwIRWQwDCwAPAAsDER0LARF2AgkDAABbbgoILhFYBgEAAAAAAAAAFgwPEYUBDBQKABAAChQKAS44DwoCLjgPETEMFgwVCgAKAxQMCS4LCREwDBAKABAADhARNQwRCgAQAA4QERwLBA4VDhYRLwwODBMMDQwSCgAQAAsUCxELFQsWCxILDQsTCw4RMgwMDAsKAA8ADgsODAsBCwIKCBEzCgAPABEuCgAPAAoIESwKDwoAEAAOCw4MCgMOEAwKLgsKETQKAAsPESoKAAoDCggRJwoACwULBgsHCwMLCBEKCgAQABEtCgAPBhUKAA8AEYQBCwARCwIKAAAAXGoKABAAQToMBwoHBgAAAAAAAAAAJARjBQkLBwYBAAAAAAAAABcMBwoAEAAKB0I6DA0KDRF6DAwLDRF7DAkKCQoBJgQoCgAQBw4MOBQEJwoADwcODDgVAQEFYgsJCgImBFcKABAHDgw4FARACgAPBw4MOBYMCAoIFAYBAAAAAAAAABYKCBULCBQMBgVHCgAPBwsMBgEAAAAAAAAAOBcGAQAAAAAAAAAMBgsGCgMkBFYKAA8ACgc4GAwKCgALCgoECQoFESgFYgoADwAKBzgYDAsKAAsLCgQJCgURKAUECwQBCwABCwUBAgsAAABiGAoAEABBOgwCBgAAAAAAAAAADAEKAQoCIwQVBQsKAA8ACgFDOhFuCwEGAQAAAAAAAAAWDAEFBgsAAQIMAQAAYzwLABAADAoKCkE6DANAZAAAAAAAAAAADAEGAAAAAAAAAAAMAgoCCgMjBB8FDwoKCgJCOgwJDQEKCRFvCwkRfDgZRGQLAgYBAAAAAAAAABYMAgUKCwoBCwE4GgwEBgAAAAAAAAAADAcRhQERgwEXDAgGAAAAAAAAAAAMBQoHCggjBDoFMQ0EOBsMBgwFCwcLBhYMBwUsCwUCDQEAAAMECwAQBhQCDgEAAAMGCwAQAAsBESIRewIPAQAAAwYLABAACwERIhF4AhABAAADBgsAEAALAREiEXkCEQEAAAMDCwAQAgISAwAAAwwKABAAQToKABAFQQ4XCwAQBDgcFgITAwAAGAgLABAACwERGgwCDgI4DAIUAAAAAwULABAACwERFQIVAwAAAwYLAAsBERYGAAAAAAAAAAAkAhYAAABrIQoAQToMAwYAAAAAAAAAAAwCBgAAAAAAAAAADAQKAgoDIwQbBQwKAAoCQjoKARFwBBYLBAYBAAAAAAAAABYMBAsCBgEAAAAAAAAAFgwCBQcLAAELAQELBAIXAAAAAwcLABAECwERGAYAAAAAAAAAACQCGAAAAGshCgA4HAwDBgAAAAAAAAAADAIGAAAAAAAAAAAMBAoCCgMjBBsFDAoACgI4HQoBEXAEFgsEBgEAAAAAAAAAFgwECwIGAQAAAAAAAAAWDAIFBwsAAQsBAQsEAhkAAAADEAoAEAEKATgGBAsLAA8BCwE4HhGCAQILAA8ACwERHQIaAAAAYh8KAEE6DAMGAAAAAAAAAAAMAgoCCgMjBBsFCgoACgJCOhF6CgEhBBYLAAELAjgfAgsCBgEAAAAAAAAAFgwCBQULAAE4IAIbAAAAYh8KADgcDAMGAAAAAAAAAAAMAgoCCgMjBBsFCgoACgI4HRF6CgEhBBYLAAELAjgfAgsCBgEAAAAAAAAAFgwCBQULAAE4IAIcAAAAcC4KAUE7DAUGAAAAAAAAAAAMAwcUDAYKAwoFIwQoBQwKAQoDQjsUDAIKAAsCERoMBA4EOAwEGQUfCwABCwEBBwknDQYLBDghRA4LAwYBAAAAAAAAABYMAwUHCwABCwEBCwYCHQMAAE4WCgALAQwCLgsCERoMBA4EOAwECwUPCwABBwknDQQ4DQwDCwALA0M6Ah4AAABxLQoAEAAKAREaDAUOBTgMBBANBTgNDAMLAA8ACwNDOgIKABAECgERGwwGDgY4DAQgDQY4DQwECwAPBAsEOCICCwIEIwUnCwABBw4nCwAPAQsBOB4RggECHwMAAAMHCwALARF/FAsCER4CIAMAADsICwERWQwCCwALAgkRHgIhAwAAOwgLARFZDAILAAsCCBEeAiIAAAB2EwoACwERGgwDDgM4DAQIBQwLAAEHCScNAzgNDAILAAsCQjoCIwMAAHc5CgAQAAoBERoMBw4HOAwECwgMAwUPCgIHACEMAwsDBBkNBzgNDAULABAACwVCOgIKABAECgERGwwIDgg4DAQkCAwEBSgLAgcBIQwECwQEMg0IOA0MBgsAEAQLBjgdAgsADwELATgeEYIBLgIkAQAAdhUKABAACwERGgwDDgM4DAQJBQ0LAAEHCScNAzgNDAILABAACwJCOgIlAQAAdhUKABAECwERGwwDDgM4DAQJBQ0LAAEHEScNAzgNDAILABAECwI4HQImAwAAeCcKARF+FAwGCgIHACEEEAsACwYMAy4LAxEkDAQFFQsACwYLAhEjDAQLBAwHCgE4IwwFCwcRcg4FIQQgBSQLAQEHEycLARF9AicAAAB8IAoADwURKwoAEAU4JCAEGQUJCgAPBUUODAMKAA8ACwM4GAwECgALBAoBCAoCESgFAwsBAQsAAQsCAQIoAAAAfjoKBC4RWAYBAAAAAAAAABYMBQ4BEXoMBg4BEXkMBwoADwIKBzgJAQoAEAcOBjgUBBwKAA8HDgY4FQEBCgAQBhQOARF7FwoADwYVCwIKBhEpCgULBg4BEXkLAxIEOCUNAQsFEWwLAA8DCwcLAQsEEYABOAoCKQAAAIABRQoADgEMAi4LAjgmBAwKAA4BOCcBAQoALjgoDAcOB0E7DAUGAAAAAAAAAAAMBAoECgUjBEIFGg4HCgRCOwwGCgAKBjgpDAgKCA4BDAMuCwM4KgQ5CggOATgrCwguOCwENgoACwY4JwEBBTgLBgEFPQsIAQsGAQsEBgEAAAAAAAAAFgwEBRULAAECKgAAADocCgAQBDgtIAQZBQYKAA8EOC4MAg0CCgERaQoBDgIReg4CEXkSAzgvCgAPAAsCRDoFAAsAAQIrAAAAiQE5CgAuQQ4MBgYBAAAAAAAAAAwECgQKBiMENgULCgAKBAwBLgsBQg4UDAMKBAwFCgUGAAAAAAAAAAAkBDEFGgsFBgEAAAAAAAAAFwwFCgAKBQwCLgsCQg4UCgMkBCkFKgUxCgAKBQoFBgEAAAAAAAAAFkcOBRULBAYBAAAAAAAAABYMBAUGCwABAiwAAABiGgoALkE6DAMGAAAAAAAAAAAMAgoCCgMjBBUFCwoACgJDOgoBEXQLAgYBAAAAAAAAABYMAgUGCwABCwEBAi0AAACLAR4GAAAAAAAAAAAMAwoAQToMAgYAAAAAAAAAAAwBCgEKAiMEGgUMCgAKAUI6DAQLAwsEEXsWDAMLAQYBAAAAAAAAABYMAQUHCwABCwMCLgAAAGIXCgAuQToMAgYAAAAAAAAAAAwBCgEKAiMEFAULCgAKAUM6EWoLAQYBAAAAAAAAABYMAQUGCwABAi8AAACMAUUGAAAAAAAAAAAMCDgwDAQGAAAAAAAAAAAMCTgwDAUNAC44JCAEPAUODQBFDgwKCgIKCkIOFDUKATUYBwMaDAYNBAoKCgY0ODELCAsGNBYMCAoDCgpCDhQ1CgE1GAcDGgwHDQULCgoHNDgxCwkLBzQWDAkFCAsDAQsCAQsICwQLCQsFAjAAAACNASgHFQwFDgE4MiAEJAUHDQE4MwwEDAYKAAoGERMEEAUUCwABBwUnCgAQAAwDCwQ4NAwCCwMOAhE1EYMBJgQjDQULBkQ7BQILAAELBQIxAAAAkAEvQA4AAAAAAAAAAAwHQA4AAAAAAAAAAAwICgBBOgwFCwMKBRoMCQYAAAAAAAAAAAwECgQKBSMEKgUSCgAKBEI6EXw1CgI1GAoBNRoMBg0HCwY0RA4NCAoJRA4LBAYBAAAAAAAAABYMBAUNCwABCwcLCAIyAAAAkQFsCwELAhcMFkAOAAAAAAAAAAAMDEAOAAAAAAAAAAAMDgoAQToMFAoUDgY4NRcMFQYAAAAAAAAAAAwTChMKFCMEZwUXCgAKE0I6EXw1DBkOAwoTQg4UDBcOBg4TODYEMA4GDhM4NxQMDwsXCw8XDAkFPQoFNQsZGAoWNRoMEAsXCxA0FgwJCwkMCw0MCwtEDg4EChNCDhQMGA4IDhM4NgRVDggOEzg3FAwRCxgLERcMCgVdCgcKFRoMEgsYCxIWDAoLCgwNDQ4LDUQOCxMGAQAAAAAAAAAWDBMFEgsAAQsMCw4CMwAAAJIBaQoALkE6DAcKBwYAAAAAAAAAACQECQUXCwABCwQBCwMBCwUBCwIBCwEBBxInBgAAAAAAAAAADAYKBgoHIwRcBR4KAAoGQzoMCgoBCgZCDhQMCQoDCgk4OAwICwk1CgouEWs1GAcDGgwMDQgLDDQ4OAwNDQ0KBAoCCgZCDhQ4ODg5AQ4NOA8GAAAAAAAAAAAkBFIKCi4RegwLCgoLDQsLCgURdQVUCw04OgsKCwgRbQsGBgEAAAAAAAAAFgwGBRkLAAELBAELAwELBQELAgELAQECNAAAAJcBVAoBQToMCQYAAAAAAAAAAAwICggKCSMESQUKCgEKCEI6DAwKDBF6DA0KBA4NOCYEHAoEDg04OxQ4NAwGBR4HFQwGCwYMCwoFDg04PAQnBgAAAAAAAAAADAcFKQYBAAAAAAAAAAwHCwcMCgoACw0KDBFvCgwRewoMEXwKDBFrCgIKCEIOFAoDCghCDhQLDAoAEXMLCwsKEgI4PQsIBgEAAAAAAAAAFgwIBQULAQELAwELBQELBAELAgECNQEAAIsBIwYAAAAAAAAAAAwEBgAAAAAAAAAADAIKAUE7DAMKAgoDIwQdBQwKAAoBCgJCOxQRIgwFCwQLBRF8FgwECwIGAQAAAAAAAAAWDAIFBwsAAQsBAQsEAjYBAAADAwsAEAACNwEAAAMFCwAQAQsBOAYCOAEAAAMFCwAQAwsBOBICAAEABgAEAAUAAgADAAAABwA/AI8BABF2YWxpZGF0b3Jfd3JhcHBlcsMEoRzrCwYAAAAMAQAIAggQAxgwBEgGBU40B4IB0wEI1QJABpUDCgqfAwYMpQNkDYkEAg+LBAIADgEKARAADAACBAABAAIAAgMMAAMBBAAABQABAAAIAgMAAAYBBAAACwIFAAAPBgcAAgQICQEEAgYJDAEEAgkKCwEEAg8NBwAFBAcEBgQCCAMHCAEBCAABBwgAAQcIAwEIAwABBggAAQMDAwkABwgBAQgCAQcIAgEHCQABCQABBggCCVR4Q29udGV4dAlWYWxpZGF0b3IQVmFsaWRhdG9yV3JhcHBlcglWZXJzaW9uZWQGY3JlYXRlCWNyZWF0ZV92MQdkZXN0cm95BWlubmVyHGxvYWRfdmFsaWRhdG9yX21heWJlX3VwZ3JhZGUObG9hZF92YWx1ZV9tdXQKdHhfY29udGV4dBF1cGdyYWRlX3RvX2xhdGVzdAl2YWxpZGF0b3INdmFsaWRhdG9yX3NldBF2YWxpZGF0b3Jfd3JhcHBlcgd2ZXJzaW9uCXZlcnNpb25lZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAAIBBwgCAAMAAAUGBgEAAAAAAAAACwALATgAEgACAQMAAAUGCgARAwsADwA4AQICAwAABQYNABEDCwATADgCAgMAAAAFCgsALhEEBgEAAAAAAAAAIQQHBQkHACcCBAAAAAUECwAQABEIAgAAAA0AFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXKVQaEc6wsGAAAADAEALQItaAOVAdQFBOkGMgWbB/sGB5YOvB0I0itgBrIsdQqnLb0BDOQuwhENpkAuD9RABABwAUQCGQIaAhsCJwJDAkYCbgJyAngCeQKuAQKvAQBkAGcAagChAQCiAQCmAQAMBAAADQQAAAkEAAAKBAAACwMAAQQHAQAAAgAMAAMBBAEAAQQCDAEAAQYDBwAIBQIACQ4MAgcBBAELDwIADBQHAgEAAAANFQcBAwAOBgQADwcIABAIBAAREQQAEhAMABISAgATEwQAAB0AAQAAHgIDAACgAQEEAABQBQYAAFIHBgAATwcGAABRBwYAAFQIBgAAYAgGAABTCQYAAF8JBgAATQoGAABOCwYAAFUMBgAASw0GAAB6DQYAAEwOBgAAew4GAABWBwYAAJcBDwYAAJUBDwYAAJYBDwYAAJ8BDwYAAJgBDwYAAIEBDwYAAJoBDwYAAIMBDwYAAJsBDwYAAIQBDwYAAJ0BDwYAAIYBDwYAAJwBEAYAAIUBEAYAAJ4BDwYAAIcBDwYAAJkBDwYAAIIBDwYAABcREgAAJBMUAABHExQAAHETFAAALAYUAAAmExQAAKcBFRQAAKgBFRYAAKkBExcAAC8VGAAAMRMUAAAwExQAACkZEgABIF5AAQABOV07AQACQCMkAAMhIgYBAAM6URQBAANiVSIBAAOtAVMUAQADsgFQIgEAA7MBBiIBAAQqXzYBAAQ2NiIBAAUiQAYBAwc7XAYBAApIYAYBDAskJxQAC1wnKAAMHD87AgEADCMGIAIBAAwtP1kCAQAMLkNEAgEADDVCBgIBAAxKQ0kCAQANHEU7AQMNIwZBAQMNNUYGAQMNOEg7AQMNSkcGAQMNYUBBAQMOF1QSAA9jOBQAEBdXEgAQQBIeABBzUhQAEHVSFAARQCkmABFBSgYAEVQyBgARXTUGABFeMgYAEXxLBgARfUsGABF+SwYAEX9LBgARgAFOBgARiAFLBgARiQFLBgARigFLBgARiwFLBgARjAFLBgARjQFLBgARjgFLBgARjwFLBgARkAFLBgARkQFOBgARkgFLBgARkwFLBgARlAFLBgASsAE9PgATFh0tABMXVgYAExhNBgATHx0UABMyNDEAEzM0MQATNDAxABM3OjsAE0AbHAATQh0UABNNNwYAE08sBgATUCoGABNRKwYAE1IrBgATUzMGABNVOQYAE2gdFwATdh0UABOoAToWABOqAToUABOxAS8uAEMfOiE8IUIfTShGH0UfSChKKEwoSyhHHzkhNiE4ITchPVhEH0koPiEzFDIUOyE/WzUhBwoIEgsHAQgKAwMIAAgPBwgMAQgCCAMDAwMDAwMHCAwBCAABCAMQBwgDCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCAwMHCAwAAgcIAwcIDAMHCAMGCBMDAwcIAwMHCAwEBwgDCwgBCAoFBwgMBQcIAwoLCAEICgsFAQMFBwgMAwcIAwgQBwgMAwcIAwYIEwUDCBQFBwsNAgULDgEFAwcIAwoCBggMBAcIAwoCCgIGCAwLBwgDAwMLBwEICgsHAQgKAwMDAwMHCAwBCwcBCAoBBggDAQMCBggDBQEICQEGCwsCCAkFAQsOAQUDCgsIAQgKCwUBAwcIDAIDCBUCCggSBwgMAQgVAQYIFQEIEQIFCw4BBQELDQIJAAkBAQgKAQsHAQkAAQcIDAEIBhcDAwMDAwgGCAADAwELBwEICgMDCwcBCAoIDwMIBggRAwMLDQIFCw4BBQMIFQEIEgEGCAwBBRAFCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCAwMHCAwDBwgVCBIHCAwCBwgVBwgMAwcIFQMHCAwBBgoIEgEIFAMHCBUGCBMCAwcIFQYIFAEBBwgSAwcIEggUAwMHCBUDBggMAgcIFQYIDAIHCBIDAQsIAQkABAcIFQULBwEICgcIDAEGCBADBwgVCBAHCAwCBggVBQEBBAYFBgUFBwsOAQUBBggUAQYFAgYLDQIJAAkBBgkAAQkAAQsOAQkAAwcLDQIJAAkBCQAJAQIHCw0CCQAJAQYJAAEHCQECBgsOAQkABgkAAgcLDgEJAAkAAgcLDgEJAAYJAAEGCw4BCQACCQAJAQIHCBIHCAwCBwgSCgICBwgSBggSAgYIFQYIEgMHCBIKAgoCLAEDAwMDAwMBAQELBwEICgMDAwMDAwMDBAMDAwsHAQgKAwMDCwcBCAoLBwEICgsHAQgKCwcBCAoDAwMLBwEICgQLBwEICgQDAwMDBAMBBwsHAQkAAgcLBwEJAAsHAQkAAQYIEQEGCwcBCQABBwgPAgcLBwEJAAMJBwgVBwsHAQgKBwsHAQgKBwsNAgULDgEFAwMDAwcIDAYHCBELBwEICgsHAQgKCwcBCAoDAwEIBAEGCQEFCwcBCAoDCwcBCAoLCAEICgsHAQgKAQsIAQgKAgcLCAEJAAoLCAEJAAEGCwUBCQABCwUBCQACCwcBCQAHCAwCCQAFA0JhZwdCYWxhbmNlBENvaW4CSUQGT3B0aW9uA1NVSQxTdGFrZVN1YnNpZHkJU3Rha2VkU3VpC1N0b3JhZ2VGdW5kE1N1aVN5c3RlbVN0YXRlSW5uZXIVU3VpU3lzdGVtU3RhdGVJbm5lclYyFFN5c3RlbUVwb2NoSW5mb0V2ZW50EFN5c3RlbVBhcmFtZXRlcnMSU3lzdGVtUGFyYW1ldGVyc1YyBVRhYmxlCVR4Q29udGV4dB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwCVZhbGlkYXRvchVWYWxpZGF0b3JPcGVyYXRpb25DYXAMVmFsaWRhdG9yU2V0BlZlY01hcAZWZWNTZXQRYWN0aXZlX3ZhbGlkYXRvcnMNYWR2YW5jZV9lcG9jaCZhc3NlcnRfbm9fcGVuZGluZ19vcl9hY3RpdmVfZHVwbGljYXRlcwNiYWcHYmFsYW5jZQRjb2luCGNvbnRhaW5zBmNyZWF0ZRhjcmVhdGVfc3lzdGVtX3BhcmFtZXRlcnMaZGVyaXZlX3JlZmVyZW5jZV9nYXNfcHJpY2UMZGVzdHJveV9zb21lDGRlc3Ryb3lfemVybwRlbWl0BWVtcHR5BWVwb2NoEWVwb2NoX2R1cmF0aW9uX21zGGVwb2NoX3N0YXJ0X3RpbWVzdGFtcF9tcwVldmVudAxleHRyYV9maWVsZHMUZXh0cmFjdF9jb2luX2JhbGFuY2UMZnJvbV9iYWxhbmNlB2dlbmVzaXMcZ2VuZXNpc19zeXN0ZW1fc3RhdGVfdmVyc2lvbgNnZXQHZ2V0X211dBBnZXRfcmVwb3J0ZXJzX29mH2dldF9zdG9yYWdlX2Z1bmRfb2JqZWN0X3JlYmF0ZXMeZ2V0X3N0b3JhZ2VfZnVuZF90b3RhbF9iYWxhbmNlGmdldF92YWxpZGF0b3JfbXV0X3dpdGhfY3R4L2dldF92YWxpZGF0b3JfbXV0X3dpdGhfY3R4X2luY2x1ZGluZ19jYW5kaWRhdGVzI2dldF92YWxpZGF0b3JfbXV0X3dpdGhfdmVyaWZpZWRfY2FwBmluc2VydAxpbnRvX2JhbGFuY2UiaXNfYWN0aXZlX3ZhbGlkYXRvcl9ieV9zdWlfYWRkcmVzcwhpc19lbXB0eQdpc19zb21lBGpvaW4Iam9pbl92ZWMcbGVmdG92ZXJfc3RvcmFnZV9mdW5kX2luZmxvdxNtYXhfdmFsaWRhdG9yX2NvdW50E21pbl92YWxpZGF0b3JfY291bnQbbWluX3ZhbGlkYXRvcl9qb2luaW5nX3N0YWtlA25ldzNuZXdfdW52ZXJpZmllZF92YWxpZGF0b3Jfb3BlcmF0aW9uX2NhcF9hbmRfdHJhbnNmZXIabmV4dF9lcG9jaF92YWxpZGF0b3JfY291bnQGb2JqZWN0Bm9wdGlvbgpwYXJhbWV0ZXJzA3BheRBwcm90b2NvbF92ZXJzaW9uD3B1YmxpY190cmFuc2ZlchNyZWZlcmVuY2VfZ2FzX3ByaWNlBnJlbW92ZRByZXBvcnRfdmFsaWRhdG9yFXJlcG9ydF92YWxpZGF0b3JfaW1wbBFyZXF1ZXN0X2FkZF9zdGFrZRpyZXF1ZXN0X2FkZF9zdGFrZV9tdWxfY29pbhVyZXF1ZXN0X2FkZF92YWxpZGF0b3IfcmVxdWVzdF9hZGRfdmFsaWRhdG9yX2NhbmRpZGF0ZRhyZXF1ZXN0X3JlbW92ZV92YWxpZGF0b3IicmVxdWVzdF9yZW1vdmVfdmFsaWRhdG9yX2NhbmRpZGF0ZRtyZXF1ZXN0X3NldF9jb21taXNzaW9uX3JhdGUVcmVxdWVzdF9zZXRfZ2FzX3ByaWNlFnJlcXVlc3Rfd2l0aGRyYXdfc3Rha2UUcm90YXRlX29wZXJhdGlvbl9jYXAJc2FmZV9tb2RlHXNhZmVfbW9kZV9jb21wdXRhdGlvbl9yZXdhcmRzJHNhZmVfbW9kZV9ub25fcmVmdW5kYWJsZV9zdG9yYWdlX2ZlZRlzYWZlX21vZGVfc3RvcmFnZV9yZWJhdGVzGXNhZmVfbW9kZV9zdG9yYWdlX3Jld2FyZHMGc2VuZGVyHXNldF9jYW5kaWRhdGVfY29tbWlzc2lvbl9yYXRlF3NldF9jYW5kaWRhdGVfZ2FzX3ByaWNlJ3NldF9jYW5kaWRhdGVfdmFsaWRhdG9yX2NvbW1pc3Npb25fcmF0ZSFzZXRfY2FuZGlkYXRlX3ZhbGlkYXRvcl9nYXNfcHJpY2UJc2luZ2xldG9uBXNwbGl0FnN0YWtlX2FjdGl2YXRpb25fZXBvY2gNc3Rha2Vfc3Vic2lkeRRzdGFrZV9zdWJzaWR5X2Ftb3VudBlzdGFrZV9zdWJzaWR5X3N0YXJ0X2Vwb2NoDHN0YWtpbmdfcG9vbBVzdGFraW5nX3Bvb2xfbWFwcGluZ3MOc3RvcmFnZV9jaGFyZ2UMc3RvcmFnZV9mdW5kFHN0b3JhZ2VfZnVuZF9iYWxhbmNlGXN0b3JhZ2VfZnVuZF9yZWludmVzdG1lbnQOc3RvcmFnZV9yZWJhdGUDc3VpCnN1aV9zeXN0ZW0Wc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchRzeXN0ZW1fc3RhdGVfdmVyc2lvbgV0YWJsZQ10b3RhbF9iYWxhbmNlDnRvdGFsX2dhc19mZWVzHHRvdGFsX29iamVjdF9zdG9yYWdlX3JlYmF0ZXMLdG90YWxfc3Rha2UfdG90YWxfc3Rha2VfcmV3YXJkc19kaXN0cmlidXRlZAh0cmFuc2Zlcgp0eF9jb250ZXh0FXVuZG9fcmVwb3J0X3ZhbGlkYXRvchp1bmRvX3JlcG9ydF92YWxpZGF0b3JfaW1wbCB1cGRhdGVfY2FuZGlkYXRlX25ldHdvcmtfYWRkcmVzcx91cGRhdGVfY2FuZGlkYXRlX25ldHdvcmtfcHVia2V5HHVwZGF0ZV9jYW5kaWRhdGVfcDJwX2FkZHJlc3MgdXBkYXRlX2NhbmRpZGF0ZV9wcmltYXJ5X2FkZHJlc3MgdXBkYXRlX2NhbmRpZGF0ZV9wcm90b2NvbF9wdWJrZXkqdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfbmV0d29ya19hZGRyZXNzKXVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX25ldHdvcmtfcHVia2V5JnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3AycF9hZGRyZXNzKnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3ByaW1hcnlfYWRkcmVzcyp1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wcm90b2NvbF9wdWJrZXkpdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3Jfd29ya2VyX2FkZHJlc3ModXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3Jfd29ya2VyX3B1YmtleR91cGRhdGVfY2FuZGlkYXRlX3dvcmtlcl9hZGRyZXNzHnVwZGF0ZV9jYW5kaWRhdGVfd29ya2VyX3B1YmtleRJ1cGRhdGVfZGVzY3JpcHRpb24QdXBkYXRlX2ltYWdlX3VybAt1cGRhdGVfbmFtZSF1cGRhdGVfbmV4dF9lcG9jaF9uZXR3b3JrX2FkZHJlc3MgdXBkYXRlX25leHRfZXBvY2hfbmV0d29ya19wdWJrZXkddXBkYXRlX25leHRfZXBvY2hfcDJwX2FkZHJlc3MhdXBkYXRlX25leHRfZXBvY2hfcHJpbWFyeV9hZGRyZXNzIXVwZGF0ZV9uZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleSB1cGRhdGVfbmV4dF9lcG9jaF93b3JrZXJfYWRkcmVzcx91cGRhdGVfbmV4dF9lcG9jaF93b3JrZXJfcHVia2V5EnVwZGF0ZV9wcm9qZWN0X3VybBx1cGRhdGVfdmFsaWRhdG9yX2Rlc2NyaXB0aW9uGnVwZGF0ZV92YWxpZGF0b3JfaW1hZ2VfdXJsFXVwZGF0ZV92YWxpZGF0b3JfbmFtZSt1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfbmV0d29ya19hZGRyZXNzKnVwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9uZXR3b3JrX3B1YmtleSd1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfcDJwX2FkZHJlc3MrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3ByaW1hcnlfYWRkcmVzcyt1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfcHJvdG9jb2xfcHVia2V5KnVwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF93b3JrZXJfYWRkcmVzcyl1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfd29ya2VyX3B1YmtleRx1cGRhdGVfdmFsaWRhdG9yX3Byb2plY3RfdXJsCHYxX3RvX3YyCXZhbGlkYXRvcg12YWxpZGF0b3JfY2FwIHZhbGlkYXRvcl9sb3dfc3Rha2VfZ3JhY2VfcGVyaW9kHXZhbGlkYXRvcl9sb3dfc3Rha2VfdGhyZXNob2xkGHZhbGlkYXRvcl9yZXBvcnRfcmVjb3Jkcw12YWxpZGF0b3Jfc2V0FnZhbGlkYXRvcl9zdGFrZV9hbW91bnQZdmFsaWRhdG9yX3N0YWtpbmdfcG9vbF9pZB92YWxpZGF0b3Jfc3Rha2luZ19wb29sX21hcHBpbmdzHHZhbGlkYXRvcl90b3RhbF9zdGFrZV9hbW91bnQidmFsaWRhdG9yX3ZlcnlfbG93X3N0YWtlX3RocmVzaG9sZAp2YWxpZGF0b3JzBXZhbHVlB3ZlY19tYXAHdmVjX3NldB52ZXJpZmllZF9vcGVyYXRpb25fY2FwX2FkZHJlc3MKdmVyaWZ5X2NhcAx3aXRoZHJhd19hbGwEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIBAQIBAgIBAwMIAQAAAAAAAAADCAAAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAMIBgAAAAAAAAADCAcAAAAAAAAAAwgIAAAAAAAAAAQQECcAAAAAAAAAAAAAAAAAAAACCCUDZgM9Az8DpAEDqwEDowEDKAgGAQIJJQNmAz4DPQM/A6QBA6sBA6MBAygIBgICECQDRwNxA6wBCBVqCBFFCABJA6UBCw0CBQsOAQVkCA9XAVsLBwEIClgLBwEICloDWQMmAygIBgMCECQDRwNxA6wBCBVqCBFFCAFJA6UBCw0CBQsOAQVkCA9XAVsLBwEIClgLBwEICloDWQMmAygIBgQCDCQDRwNJA3YDbANpA20DawNlA3QDdwM8AwADAAAaGwsACgYRdAwIDggRbwwHBgAAAAAAAAAACwIRKQsICwERUQsECwc4AAsFCTgBOAEGAAAAAAAAAAAGAAAAAAAAAAALAwsGETQSAgIBAwAABgsLAAsBCwILAwsECwULBgsHETQSAAICAwAAJTcLABMCDBEMAwwMDA0MCwwODAoMDwwVDAkMBwwSDBcBDAgMAQsHEwAMBgwTDBYMFAwFDAQMEAwCCwELCAYCAAAAAAAAAAsXCxILAgsQBgQAAAAAAAAACwQLBQsUCxYLEwsGEgELCQsVCw8LCgsOCwsLDQsMCwMLERIDAgMDAAAmGgoPLhFBCwELAgsDCwQLBQsGCwcLCAsJCwoLCwsMCw0LDgoPEVQMEAsADwALEAsPEXgCBAMAAAYFCwAPAAsBEXoCBQMAAAYZCgAQABF1CgAQARACFCMECgUQCwABCwEBBwMnCgAPAAsAEAEQAxQLARF3AgYDAAAGHwoAEAARbEEmCgAQARAEFCYEGgoAEAARdQoAEAEQBBQkBBQFGgsAAQsBAQcDJwsADwALARF5AgcDAAAuDwoADwALAQcBEYEBDAMLAA8ADgMJEXILAwsCEVYCCAMAAC4PCgAPAAsBBwIRgQEMAwsADwAOAwgRcgsDCwIRWAIJAwAABgcLAA8ACwELAi4RewIKAwAABggLAA8ACwIuEXELARFXAgsDAAAGCAsADwALAgsBOAILAxF2AgwDAAASDAsBCwIKBBExDAULAA8ACwMLBQsEEXYCDQMAAAYUDgERTwoCLhFAJQQIBQ4LAAELAgEHCScLAA8ACwELAhF8Ag4DAAAGFgoAEAAKAhFzBAYFDAsAAQsBAQcEJwoADwALAQcAEYEBCwILAA8FERACDwMAAAYKCgAPAAsBBwARgQELAgsADwUREQIQAAAAPC4OABFrFAwFCgUKASIECQUNCwIBBwYnCgIOAQwDLgsDOAMgBBsLAgsBCwU4BDgFBS0LAg4BOAYMBgoGDgUMBC4LBDgHIAQrCwYLBTgIBS0LBgECEQAAADwyCgIOAQwDLgsDOAMECAUMCwIBBwcnCgIOATgGDAYOABFrFAwFCgYOBQwELgsEOAcEHAUiCwIBCwYBBwcnCgYOBTgJCwYuOAoELwsCDgE4CwEBBTELAgECEgMAAAYICwAPAAoBLhFxCwERVQITAwAABgcLAA8ACwIRcQsBEWICFAMAAAYHCwAPAAsCEXELARFgAhUDAAAGBwsADwALAhFxCwERYQIWAwAABgcLAA8ACwIRcQsBEWoCFwMAAEwQCgAPAAsCEXAMAwoDCwERYwsDLgwECwAQAAsEEW4CGAMAAAYHCwAPAAsCEXELARFZAhkDAABMEAoADwALAhFwDAMKAwsBEWULAy4MBAsAEAALBBFuAhoDAAAGBwsADwALAhFxCwERWwIbAwAABgcLAA8ACwIRcAsBEWYCHAMAAAYHCwAPAAsCEXELARFcAh0DAAAGBwsADwALAhFwCwERaAIeAwAABgcLAA8ACwIRcQsBEV4CHwMAAEwRCgAPAAsDEXAMBAoECwELAhFnCwQuDAULABAACwURbgIgAwAABggLAA8ACwMRcQsBCwIRXQIhAwAATBAKAA8ACwIRcAwDCgMLARFpCwMuDAQLABAACwQRbgIiAwAABgcLAA8ACwIRcQsBEV8CIwMAAEwQCgAPAAsCEXAMAwoDCwERZAsDLgwECwAQAAsEEW4CJAMAAAYHCwAPAAsCEXELARFaAiUDAABP0AIKABAGFAwlCgkKAA8GFQcMNAwcCgcKHCUEFAoICxwlDAsFFgkMCwsLBBkFHwsAAQsKAQcIJwoADwc4DAwoDQMLKDgNAQoADwg4DAwnDQQLJzgNAQsFCgAQCRQWDAUGAAAAAAAAAAAKAA8JFQsGCgAQChQWDAYGAAAAAAAAAAAKAA8KFQoAEAARfgw2CgAQCxFSDCwKLAs2Fgw0DgM4DgwrDgQ4DgwdCgouEUAKABABEAwUJgRoCwkLJQoAEAEQDRQWJgwUBWoJDBQLFARxCgAPDhFODBUFczgBDBULFQwpDik4DgwqDQQLKTgNAQs0NQw1Ch01DB4LLDULHhgLNRoMMA0ECjA0OA8MLwswCwc1GAcMGgwuDS8KLjQ4DwwtCgAQDxQGAQAAAAAAAAAWCgAPDxULAQoAEA8UIQSpAQWvAQsAAQsKAQcLJw4EOA4MIA4vOA4MMgoADwANBA0vCgAPBQsICgAQARAQFAoAEAEQERQKABABEBIUCwoRbQoAEAARfgwkDgQ4DgwfDi84DgwxCyALHxcMIQsyCzEXDDMLAgoADxMVCgAQABFvCgAPFBULLwwiDSILBDgNAQ4iOA4MIwoADwsLAwstCyIKBQsGEVAMJgoAEA8UDBYKABATFAwXCgAQFBQMGAskDBkLKwwaCy40DBsLBQwMCgAQCxFSDA0LKgwOCx0MDwshCzMWDBALIwwRCxYLFwsYCxkLGwsaCwwLDQsOCw8LEAsREgQ4EAkKAA8VFQoAEAkUBgAAAAAAAAAAIQS6AgoAEAc4DgYAAAAAAAAAACEMEgW8AgkMEgsSBMUCCwAQCDgOBgAAAAAAAAAAIQwTBckCCwABCQwTCxMEzAIFzgIHCicLJgImAwAABgQLABAPFAInAwAABgQLABATFAIoAwAABgQLABAWFAIpAwAABgIHAwIqAwAABgQLABAGFAIrAwAABgULABAACwERgAECLAMAAAYFCwAQAAsBEX8CLQMAAAYECwAQABF9Ai4DAAAYEgoAEAUOATgDBAwLABAFDgE4ERQMAgUQCwABOBIMAgsCAi8DAAAGBAsAEAsRUgIwAwAABgQLABALEVMCMQAAAFotDQBFWwwGDQYLADgTCwY4AgwHDgE4FAQnCwE4FQwEDQcLBDgPDAUOBzgOBgAAAAAAAAAAJAQgCwcKAjgWCwIuEUE4FwUkCwIBCwc4GAsFDAMFKwsCAQsHDAMLAwIDAwMFAQMBBAECAwcDDgMKAwsDDAMNAwQBAQEAAwgDAAEFAQYBBwMBAwYDCQMCACsAbwAdDXZhbGlkYXRvcl9jYXAfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9jYXAVVmFsaWRhdG9yT3BlcmF0aW9uQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMc3Rha2luZ19wb29sC1N0YWtpbmdQb29sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMc3Rha2luZ19wb29sFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbAlTdGFrZWRTdWkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwl2YWxpZGF0b3IRVmFsaWRhdG9yTWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwl2YWxpZGF0b3IJVmFsaWRhdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJdmFsaWRhdG9yE1N0YWtpbmdSZXF1ZXN0RXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwl2YWxpZGF0b3IVVW5zdGFraW5nUmVxdWVzdEV2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMdm90aW5nX3Bvd2VyD1ZvdGluZ1Bvd2VySW5mbwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHZvdGluZ19wb3dlchFWb3RpbmdQb3dlckluZm9WMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEXZhbGlkYXRvcl93cmFwcGVyEFZhbGlkYXRvcldyYXBwZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0DFZhbGlkYXRvclNldAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9zZXQXVmFsaWRhdG9yRXBvY2hJbmZvRXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0GVZhbGlkYXRvckVwb2NoSW5mb0V2ZW50VjIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0ElZhbGlkYXRvckpvaW5FdmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9zZXQTVmFsaWRhdG9yTGVhdmVFdmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0b3JhZ2VfZnVuZAtTdG9yYWdlRnVuZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXN0YWtlX3N1YnNpZHkMU3Rha2VTdWJzaWR5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchBTeXN0ZW1QYXJhbWV0ZXJzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchJTeXN0ZW1QYXJhbWV0ZXJzVjIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxZzdWlfc3lzdGVtX3N0YXRlX2lubmVyE1N1aVN5c3RlbVN0YXRlSW5uZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxZzdWlfc3lzdGVtX3N0YXRlX2lubmVyFVN1aVN5c3RlbVN0YXRlSW5uZXJWMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIUU3lzdGVtRXBvY2hJbmZvRXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwpzdWlfc3lzdGVtDlN1aVN5c3RlbVN0YXRlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMHZ2VuZXNpcxhHZW5lc2lzVmFsaWRhdG9yTWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwdnZW5lc2lzFkdlbmVzaXNDaGFpblBhcmFtZXRlcnMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwdnZW5lc2lzGVRva2VuRGlzdHJpYnV0aW9uU2NoZWR1bGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwdnZW5lc2lzD1Rva2VuQWxsb2NhdGlvbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwpzdWlfc3lzdGVtDlN1aVN5c3RlbVN0YXRlAAAAAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFY2xvY2sFQ2xvY2sAAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAACAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pAQAAAAAAAAAEBGNsb2KTSaEc6wsGAAAADQEAIwIjdgOZAbkEBNIFtgEFiAflCQftEKcOCJQfYAb0H50CCpEisAELwSMIDMkjvyQNiEgsDrRIHAArADMANABaAWcBhAECGgIsAi0CPgJSAmUCegJ9AoIBAoMBAA4HAAAMBwIAAQABAAoHAgABAAEACwcCAAEAAQAJBgAAEQQAAA0IAgABAAEBBAQBBAACAAwAAgUMAQABBAgHAQAABRMHAAYBBAEAAQcCCAAIAwwBAAEKBwwCBwAEAQsGBwALFAQADA8CAA0QDAIHAQQBDxICAAA6AAEAAC8CAwAAMQQBAgAAADAFAQIAAAA3BgECAAAAOAcBAgAAAIkBCAkCAAAAiwEICgIAAAB7CwwCAAAAfA0MAgAAAFkODwIAAABYDg8CAAAAVxAPAgAAAGwREgIAAABLExQCAAAAaxUWAgAAAGkUFwAAPRgBAgAAACoZAQIAAAB3GhsCAAAAKRwBAgAAACIdAQIAAABTHh8CAAAAFh4gAgAAAEchIgIAAABGISICAAAARSMUAgAAAEgkJQIAAAElVDoBBAEmVDoBBAEoRkcBBAFAVBQBBAFBVE0BBAFMWxQBBAFPRBcBBAFbREUBBAFcREUBBAFgAjABBAFkVEUBBAFuVEUBBAF2RioBBAIVYRQBAAIWYUUBAAI1WjQBAAI2TDQBAAJKPAEBAAJUWgEBAAJdAgMAAmACMwEAAoYBTAEBAAKKAT0JAQACjAE9CQEAAztFTQADXkUUAANfRU0ABCRJOgEABFBJFwEABUQBKwEABlFPFAEABnlONAEABogBQRQBAAaNAQE0AQAHgAFAFAAIQkIJAQAITQk0AQAIUVgBAQAIiAE5FAEACTwqAQEDChlISQIHBAokSksCBwQKJ1NSAgcECi5KFwIHBAo5KAECBwQKQ0hJAgcECk9IFwIHBApgAigCBwQKYUpJAgcECnBcAQIHBAp1UywCBwQLSTo7AQgLYAItAAuFAS4vAA0XXwECBwQNJF5LAgcEDSdRUgIHBA0uXhcCBwQNYAIyAgcEDngqAQEISCc5KjksJQBWMTAqMCw9Kj0sVzZDN0I4QDgCNU8DQCotKkAsLSwyKjMsQiwNNQo1PCo/Kj8sIgAkAB4ASSc3FEonRScxKiwqOyo6KjssQ1BMJzgUVDFORU4nRicmACgAIAARNSMAMSwsLDosJwALNUEqQioMNUEsLiwuKksnIQBNJ0NdVTFLRVIxTUUpLCssPCwrKg41Q2JHRUVFEzUcAEcnSkVERVMxSUUdAExFKioqLB8AGjUBCAUAAQcIFAEICAYDAwMDCwwBCBIHCBQEAwMLDgEIEgcIFAMHCwYCCQAJAQsOAQkABggIAwcLBgIJAAkBCw4BCQEGCAgEBwsGAgkACQEDBggIBwgUAQsOAQkAAQsOAQkBBgcLBgIJAAkBAwsOAQkACw4BCQEGCA0HCBQDCw4BCQALDgEJAQMFBwsGAgkACQEDBggNCw4BCQEHCBQFBwsGAgkACQEDAwMLDAEJAQILDAEJAAsMAQkBBAcLBgIJAAkBAwMLDAEJAAcHCwYCCQAJAQMBCw4BCQALDgEJAQYIDQcIFAILDgEJAAsOAQkBBwcLBgIJAAkBAwMBAwYICAcIFAEDCQcLBgIJAAkBAwMBAwIGCA0GCAgHCBQEAwMBAwEBAggQBggEAwcLBgIJAAkBAwYICAUHCwcBCAUHCw8CAwMDAwgQAQgEAgcLBgIJAAkBBggIAwcLBgIJAAkBCgMGCAgCBgsGAgkACQEGCAgBCggEBAMDAwMEBgsGAgkACQEDAwYIDQIKAwoDAwYLBwEIBQMDAwYLBgIJAAkBAwYICAEGCAQBCw8CAwgEAgMIBAELDwIJAAkBBAgLCBAIEQgLAQkAAQgLAQkBAQgRAQYIEQEGCBABCwcBCQACCBALDwIDAwELEwIJAAkBAQsJAQkAAQsMAQkAAgkACQEBCwYCCQAJAQEIAAEIEgEGCw4BCQABBgkAAQgQAwcLCQEJAAgQCwwBCQAEBwsJAQkAAwYICAcIFAQDCw4BCQALDgEJAQMDCwwBCQALDAEJAQMBBggNAQYLDAEJAAILDAEJAAcIFBoBAwEDAwcLBwEIBQsMAQkAAwMLDAEJAAMGCAQHCAQDAwYLCgEDAwMLDAEJAQEDCwwBCQADAwcIBQMBBgsHAQkAAgMDAgcLBwEJAAMBBwkAAQYLDwIJAAkBAQYLCgEJAAIGCw8CCQAJAQkAAQYJAQMHCwkBCQAIEAMCAQMCBwsMAQkAAwIHCwwBCQALDAEJAAELAwIJAAkBAgcLEwIJAAkBCQABBwkBAgcLDwIJAAkBCQACBgsHAQkAAxoBAwEDAwcLBwEIBQsMAQkAAwMLDAEJAAMGCAQHCAQDBgsKAQMDAwgQCwwBCQEBAwMLDAEJAAMHCAUDGwEDAQMDBwsHAQgFCwwBCQADAwsMAQkBAwYIBAcIBAMDBgsKAQMDAwgQCwwBCQEBAwMLDAEJAQMHCAUDAwsMAQkACwwBCQELDAEJAQIHCw4BCQALDgEJAAcDBwsHAQgFCAQDAwMIEAMHCwkBCQAGCAgDAwcLBwEJAAMJAAMHCw8CCQAJAQkACQEBCwECCQAJAQIGCxMCCQAJAQkAAwcLEwIJAAkBCQAJAQsLDAEJAAsMAQkACwwBCQADAwsMAQkBCwwBCQELDAEJAQMDCBACBgsJAQkACBABCwICCQAJAQsDAwYLBwEIBQcLBwEIBQMBCAQDAwgQBwsPAgMDAwMHCAUIBA0DBwsHAQgFAwMBBwsHAQgFCAQDAwgQAwgQBwsPAgMDEgYLBwEIBQMDBgsHAQgFBwsHAQgFAwMBAwMDCAQDCBADAwgQBwsPAgMDBwYIBQoIBAYIBAYLCgEDAwgQBgsPAgMDBQMDAwMIEAYDCgMDAwMKAwQDBggEBgsKAQMGCw8CAwgEAwYLBwEIBQMIEApBY2NvdW50Q2FwB0JhbGFuY2UFQ2xvY2sEQ29pbgtDcml0Yml0VHJlZQlDdXN0b2RpYW4CSUQLTGlua2VkVGFibGUGT3B0aW9uBU9yZGVyDU9yZGVyQ2FuY2VsZWQLT3JkZXJGaWxsZWQLT3JkZXJQbGFjZWQEUG9vbAtQb29sQ3JlYXRlZANTVUkFVGFibGUJVGlja0xldmVsCVR4Q29udGV4dAhUeXBlTmFtZQNVSUQZYWNjb3VudF9hdmFpbGFibGVfYmFsYW5jZQ9hY2NvdW50X2JhbGFuY2UDYWRkBGFza3MEYmFjawdiYWxhbmNlCmJhc2VfYXNzZXQcYmFzZV9hc3NldF9xdWFudGl0eV9jYW5jZWxlZBpiYXNlX2Fzc2V0X3F1YW50aXR5X2ZpbGxlZBpiYXNlX2Fzc2V0X3F1YW50aXR5X3BsYWNlZB1iYXNlX2Fzc2V0X3F1YW50aXR5X3JlbWFpbmluZxdiYXNlX2Fzc2V0X3RyYWRpbmdfZmVlcw5iYXNlX2N1c3RvZGlhbhJiYXRjaF9jYW5jZWxfb3JkZXIEYmlkcwZib3Jyb3cUYm9ycm93X2xlYWZfYnlfaW5kZXgSYm9ycm93X2xlYWZfYnlfa2V5CmJvcnJvd19tdXQYYm9ycm93X211dF9sZWFmX2J5X2luZGV4EWNhbmNlbF9hbGxfb3JkZXJzDGNhbmNlbF9vcmRlcgRjbG9iBWNsb2NrBGNvaW4IY29udGFpbnMOY3JlYXRlX2FjY291bnQLY3JlYXRlX3Bvb2wMY3JlYXRlX3Bvb2xfDGNyZWF0aW9uX2ZlZQdjcml0Yml0CWN1c3RvZGlhbh9kZWNyZWFzZV91c2VyX2F2YWlsYWJsZV9iYWxhbmNlHGRlY3JlYXNlX3VzZXJfbG9ja2VkX2JhbGFuY2UMZGVwb3NpdF9iYXNlDWRlcG9zaXRfcXVvdGUNZGVzdHJveV9lbXB0eRNkZXN0cm95X2VtcHR5X2xldmVsCWRpdl9yb3VuZARlbWl0E2VtaXRfb3JkZXJfY2FuY2VsZWQFZXZlbnQQZXhwaXJlX3RpbWVzdGFtcBBmaW5kX2Nsb3Nlc3Rfa2V5CWZpbmRfbGVhZgxmcm9tX2JhbGFuY2UFZnJvbnQDZ2V0FmdldF9sZXZlbDJfYm9va19zdGF0dXMfZ2V0X2xldmVsMl9ib29rX3N0YXR1c19hc2tfc2lkZR9nZXRfbGV2ZWwyX2Jvb2tfc3RhdHVzX2JpZF9zaWRlEGdldF9vcmRlcl9zdGF0dXMCaWQfaW5jcmVhc2VfdXNlcl9hdmFpbGFibGVfYmFsYW5jZRJpbmplY3RfbGltaXRfb3JkZXILaW5zZXJ0X2xlYWYMaW50b19iYWxhbmNlBmlzX2JpZAhpc19lbXB0eQdpc19ub25lBGpvaW4MbGlua2VkX3RhYmxlEGxpc3Rfb3Blbl9vcmRlcnMMbG9ja19iYWxhbmNlCGxvdF9zaXplEW1ha2VyX3JlYmF0ZV9yYXRlCW1hdGNoX2FzawltYXRjaF9iaWQdbWF0Y2hfYmlkX3dpdGhfcXVvdGVfcXVhbnRpdHkEbWF0aAhtYXhfbGVhZghtaW5fbGVhZhBtaW50X2FjY291bnRfY2FwA211bAltdWxfcm91bmQDbmV3BG5leHQRbmV4dF9hc2tfb3JkZXJfaWQRbmV4dF9iaWRfb3JkZXJfaWQJbmV4dF9sZWFmBm9iamVjdAtvcGVuX29yZGVycwZvcHRpb24Ib3JkZXJfaWQMb3JkZXJfaXNfYmlkBW93bmVyEXBsYWNlX2xpbWl0X29yZGVyEnBsYWNlX21hcmtldF9vcmRlcgdwb29sX2lkDXByZXZpb3VzX2xlYWYFcHJpY2UJcHVzaF9iYWNrCHF1YW50aXR5C3F1b3RlX2Fzc2V0GHF1b3RlX2Fzc2V0X3RyYWRpbmdfZmVlcw9xdW90ZV9jdXN0b2RpYW4GcmVtb3ZlFHJlbW92ZV9sZWFmX2J5X2luZGV4DHJlbW92ZV9vcmRlcgxzaGFyZV9vYmplY3QFc3BsaXQDc3VpGXN3YXBfZXhhY3RfYmFzZV9mb3JfcXVvdGUZc3dhcF9leGFjdF9xdW90ZV9mb3JfYmFzZQV0YWJsZQ50YWtlcl9mZWVfcmF0ZQl0aWNrX3NpemUMdGltZXN0YW1wX21zDnRvdGFsX3F1YW50aXR5CHRyYW5zZmVyCnR4X2NvbnRleHQJdHlwZV9uYW1lDHVpZF9hc19pbm5lcg51bmxvY2tfYmFsYW5jZQ91c3Jfb3Blbl9vcmRlcnMFdmFsdWUNd2l0aGRyYXdfYmFzZRN3aXRoZHJhd19iYXNlX2Fzc2V0DndpdGhkcmF3X3F1b3RlFHdpdGhkcmF3X3F1b3RlX2Fzc2V0BHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAMIBgAAAAAAAAADCAcAAAAAAAAAAwgIAAAAAAAAAAMICQAAAAAAAAADCAoAAAAAAAAAAwgLAAAAAAAAAAMIDAAAAAAAAAADCA0AAAAAAAAAAwgPAAAAAAAAAAMIEAAAAAAAAAADCBEAAAAAAAAAAwgSAAAAAAAAAAMIEwAAAAAAAAADCBQAAAAAAAAAAwgVAAAAAAAAAAMIFgAAAAAAAAACAQQCAQACAQECAQICAQMDCAAAAAAAAAAAAwgAAAAAAAAAgAMIQEtMAAAAAAADCKAlJgAAAAAAAwgA6HZIFwAAAAMIAMqaOwAAAAAAAgdtCBAbCAtyCAt+A1YDfwNVAwECBm0IEGgDTgFqCBAeA28DAgIGbQgQaANOAWoIEBwDbwMDAghtCBBoA04BaggQgQEDHQMfA28DBAIGaANvA3EDTgFqCBA/AwUCAm8DZgsPAgMIBAYCD0kIESMLBwEIBRgLBwEIBWMDYgOHAQsTAggQCw8CAwN+A1YDfwNVAyELCQEJAHQLCQEJATILDAEIEiALDAEJAHMLDAEJAQY1AzUBNQI1AAAAACYHCwATBQwBAQsBOAACAQEAAAEDCwARLwICAAAAKT04AQwGOAIMCQoGCgkiBAkFDQsFAQcPJwoACgEmBBIFFgsFAQcBJwoFEVAMCA4IEVEUDAcLCAoFOAMKBTgDBxoHGwoFOAQKAAoBCgIKAwoFOAULBTgGCwQ4BzgIOQA4CQsHCwYLCQsACwELAgsDEgA4CgIDAQAAARMOAjgLBx4hBAYFCgsDAQcTJwccBx0LAAsBCwI4DAsDOA0CBAEAAAEICwA2AAsCOA4LATgPOBACBQEAAAEICwA2AQsCOA4LATgROBICBgEAAAEHCwA2AAsBCwILAzgTAgcBAAABBwsANgELAQsCCwM4FAIIAQAAPhYOAzgVDAYLAAsBCQsCCwMLBAsFOBYMCAwHDgg4FQwJCwcLCAsJCwYXAgkBAAA/FQsACwEHGwsCET4LAzgROBcMBgwFDgU4GAwHCwUKBDgZCwYLBDgaCwcCCgAAAEOtAgsBDBs4BwwLCwQMFwoANgIMCgoKLjgbBBQLAAELCgELCwsXAgoKLjgcDBwMHgoKLjgbIAQkBR8KHgoCJQwFBSYJDAULBQSqAgoKChw4HQwdCh0QAzgeOB8UDBYKHRADOCAgBIgCBTgKHRADChY4IQwQChAQBBQMDwkMGAoQEAUUCgMlBFUIDBgKADYAChAQBhQKEBAEFDgiBcsBCg8KEBAHFBE2DBIEYAsSBgEAAAAAAAAAFgwSChsKEiYEZwsSDAYFaQobDAYLBgwNCg0KEBAHFBE0DAwEdgsMBgEAAAAAAAAAFgwMCgwKADcDFBE1DBMKDAoANwQUETYMGQSHAQsZBgEAAAAAAAAAFgwZCw8KDBcMDwsbCg0XDBsKADYAChAQBhQKDDgjDA4NDgsZOCQMGgoANgAKEBAGFA0aCxM4JDgQCgA2BQsaOCUBDQsLDjglAQoANgEKEBAGFA0XCw04JjgSCgA3BhFRFAoQEAwUCQoQEAYUChAQBBQLDAoPChAQBxQ5ATgnCxgE0AEIDAcF1AEKDwYAAAAAAAAAACEMBwsHBPcBChYMFQodEAMKFjgoDBQKFDgpIATmAQsUOB8UDBYF6AELFAEKADYHCxAQBhQ4KgoVOCsBCh0PAwsVOCwBBYICCxABCh0PAwoWOC0MEQsPCxEPBBUKGwYAAAAAAAAAACEEhwIFiAIFMgsdEAM4IASgAgoKCx4MCC4LCDguAQweCgoLHDgvEQAKCgoeDAkuCwk4MAwcAQobBgAAAAAAAAAAIQSpAgsAAQsKAQWqAgUZCwsLFwILAAAAVaICCgA3BhFRFAwWCwEMGTgHDAsLBAwXCgA2AgwKCgouOBsEGQsAAQsKAQsLCxcCCgouOBwMHAweCgouOBsgBCkFJAoeCgIlDAUFKwkMBQsFBJ8CCgoKHDgdDB0KHRADOB44HxQMFQodEAM4ICAE/QEFPQodEAMKFTghDBAKEBAEFAwPCQwYChAQBRQKAyUEXQgMGAoANgAKEBAGFAoQEAQUOCIKFgoQODEFwAEKGQoPJgRkCg8MBgVmChkMBgsGDAwKDAoQEAcUETUMDQoMCgA3AxQRNQwSCgwKADcEFBE2DBoEfwsaBgEAAAAAAAAAFgwaCw8KDBcMDwsZCgwXDBkKADYAChAQBhQKDDgjDA4NDgsaOCQMGwoANgAKEBAGFA0bCxI4JDgQCgA2BQsbOCUBDQsLDjglAQoANgEKEBAGFA0XCw04JjgSChYKEBAMFAkKEBAGFAoQEAQUCwwKDwoQEAcUOQE4JwsYBMUBCAwHBckBCg8GAAAAAAAAAAAhDAcLBwTsAQoVDBQKHRADChU4KAwTChM4KSAE2wELEzgfFAwVBd0BCxMBCgA2BwsQEAYUOCoKFDgrAQodDwMLFDgsAQX3AQsQAQodDwMKFTgtDBELDwsRDwQVChkGAAAAAAAAAAAhBPwBBf0BBTcLHRADOCAElQIKCgseDAguCwg4LgEMHgoKCxw4LxEACgoKHgwJLgsJODAMHAEKGQYAAAAAAAAAACEEngILAAELCgEFnwIFHgsLCxcCDAAAAFaqAgoANwYRURQMFgsDDAo4CAwXCgA2CAwJCgkuOBsEFwsAAQsJAQsKCxcCCgkuODIMHAweCgkuOBsgBCcFIgoeCgEmDAQFKQkMBAsEBKcCCgkKHDgdDB0KHRADOB44HxQMFQodEAM4ICAEhAIFOwodEAMKFTghDA8KDxAEFAwOCQwYCg8QBRQKAiUEYQgMGAoPEAQUCg8QBxQRNQwRCgA2AQoPEAYUCxE4MwoWCg84MQXGAQ4KOBgMGQoZCg4mBGsKDgwFBW0LGQwFCwUMCwoLCg8QBxQRNQwMCgwKADcDFBE1DBIKDAoANwQUETYMGgSGAQsaBgEAAAAAAAAAFgwaCw4KCxcMDgoANgEKDxAGFAsMODQMDQ0NCxo4JgwbCgA2AQoPEAYUDRsLEjgmOBIKADYJCxs4NQENFwsNODUBCgA2AAoPEAYUDQoKCzgkOBAKADcGEVEUCg8QDBQICg8QBhQKDxAEFAsLCg4KDxAHFDkBOCcLGATLAQgMBgXPAQoOBgAAAAAAAAAAIQwGCwYE8gEKFQwUCh0QAwoVOCgMEwoTOCkgBOEBCxM4HxQMFQXjAQsTAQoANgcLDxAGFDgqChQ4KwEKHQ8DCxQ4LAEF/QELDwEKHQ8DChU4LQwQCw4LEA8EFQ4KOBgGAAAAAAAAAAAhBIMCBYQCBTULHRADOCAEnAIKCQseDAcuCwc4NgEMHgoJCxw4LxEACgkKHgwILgsIODAMHAEOCjgYBgAAAAAAAAAAIQSmAgsAAQsJAQWnAgUcCwoLFwINAQAAV0gKAQoANwoUGQYAAAAAAAAAACEECQURCwABCwYBCwUBBwUnCwIEJwsACwEHGwsFET4LBDgRODcMCQwHDQMLBwoGOBk4OAsJCwY4GgwEBUULAQ4DODklBC0FNQsAAQsGAQsFAQcRJwsABxoLBRE+CwM4Dzg6DAgKBjgZDAMNBAsICwY4Gjg7CwMLBAIOAAAAWXUKBTgODA0KAwQeCgIKARE1DAsKADYBCwULCzg8CgA3CxQMCgoANwsUBgEAAAAAAAAAFgoANgsVCgA2CAwIBTIKADYACwUKAjg9CgA3DBQMCgoANwwUBgEAAAAAAAAAFgoANgwVCgA2AgwICgoKAQoCCgMKDQsEEgQMCQoICgEMBy4LBzgwDAwgBEsKCAoBCgEKBjg+EgU4PwwMCwgLDDgdDwMKCgsJOEAKADcGEVEUCgoLAwoNCwIKATkCOEEKADcHCg04QiAEagoANgcKDQsGOEM4RAVsCwYBCwA2BwsNOCoKCgsBOEULCgIPAQAAYPIBCgIGAAAAAAAAAAAkBAUFDwsAAQsIAQsGAQsHAQcFJwoBCgA3DRQZBgAAAAAAAAAAIQQYBSILAAELCAELBgELBwEHBCcKAgoANwoUGQYAAAAAAAAAACEEKwU1CwABCwgBCwYBCwcBBwUnCgQKBhE+JAQ7BUULAAELCAELBgELBwEHFCcKBzgODBMKAwRxCgA3AQoTOEYMEgoANgEKBwoSOEcMDgoACgIKAQsGET4LDjg3DBAMCg4KOBgMDAsSDhA4SBcMEQoANgAKEwsKOBAKADYBCxMLEDgSBZEBCgA2AAoHCgI4SQwJCgAKAQsGET4LCTg6DA8MCwoCDgs4GBcMDA4POEgMEQoANgAKEwsLOBAKADYBCxMLDzgSCgUHFyEEoAELAAELCAELBwELDAsRCQYAAAAAAAAAAAIKBQcYIQS2AQsAAQsIAQsHAQoMCwIhBK8BBbEBBwgnCwwLEQkGAAAAAAAAAAACCgUHGSEE1QEKDAYAAAAAAAAAACEEvwEFxwELAAELCAELBwEHCScLAAsBCwILAwsECwcLCDhKDA0LDAsRCAsNAgsFBxYhBNoBBeIBCwABCwgBCwcBBw0nCwALAQsCCgwXCwMLBAsHCwg4SgwNCwwLEQgLDQIQAAAAAQQLAAcbIwIRAAAAARMLAAoBEAwUCgEQFBQKARAGFAoBEAQUCwEQBxQ5AzhLAhIBAABjbgsCOA4MDAoANwcKDDhCBAkFDQsAAQcLJwoANgcKDDgqDA0KDQoBDAMuCwM4TAQaBSALDQELAAEHAicKDQoBDAQuCwQ4TRQMCwoBERAMCAoIBDEKADcIDAUFNAoANwIMBQsFCws4MAwKBDoFQAsNAQsAAQcCJwoIBEYKADYIDAYFSQoANgIMBgsGCw0LCgsBCgw4TgwJCwgEYA4JEAQUDgkQBxQRNQwHCgA2AQsMCwc4MwVnCgA2AAsMDgkQBBQ4IgsANwYRURQOCTgxAhMAAABkNgsBCgM4KwEKAAoCDAUuCwU4TxADCgM4UAQPBRMLAAEHAicKAAoCOB0MBgoGDwMLAzgsDAcOBxAGFAsEIQQjBSkLAAELBgEHAycLBhADOCAEMgsACwI4LxEABTQLAAELBwIUAQAAZWgKADcGEVEUDAsLATgODA0KADcHCg04QgQOBRILAAEGAAAAAAAAAAAnCgA2BwoNOCoMDgoOLjhRIARjBR0KDi44UjgfFAwJCg4KCQwCLgsCOE0UDAoKCREQDAYKBgQ0CgA2CAwDBTcKADYCDAMLAwwHCgcLCgwELgsEODAMDAELBwoOCwwLCQoNOE4MCAsGBFgOCBAEFA4IEAcUETUMBQoANgEKDQsFODMFXwoANgAKDQ4IEAQUOCIKCw4IODEFFwsOAQsAAQIVAQAAZqQBCgA3BhFRFAwQCwI4DgwTCgA3BwoTOEIEDgUSCwABBgAAAAAAAAAAJwYAAAAAAAAAAAwRCgA3CDgbIAQdCgA3CAwDBSAKADcCDAMLAwoROE8QFRQMEg4BQRQMCwYAAAAAAAAAAAwJCgA2BwoTOCoMFAoJCgsjBJ8BBTUOAQoJQhQUDA8KFAoPDAQuCwQ4TARCBUgLFAELAAEHAicKFAoPDAUuCwU4TRQMDQoPERAMCgoNChIiBHALDQwSCgoEXwoANwgMBgViCgA3AgwGCwYKEjgwDAwEaAVuCxQBCwABBwonCwwMEQoKBHYKADYIDAcFeQoANgIMBwsHChQKEQsPChM4TgwOCwoEkAEODhAEFA4OEAcUETUMCAoANgEKEwsIODMFlwEKADYAChMODhAEFDgiChAODjgxCwkGAQAAAAAAAAAWDAkFMAsUAQsAAQIWAQAAZ1QLATgODAcKADcHCwc4UwwIQBsAAAAAAAAAAAwDCgg4VAwFCgU4KSAETAUSCggKBTgfFDhNFAwGCgU4HxQREAQkCgA3CAsGOFUMAgUpCgA3AgsGOFUMAgsCEAMKBTgfFDghDAQNAwoEEAwUCgQQBxQKBBAEFAoEEBQUCgQQBhQLBBAFFBIERBsKCAsFOB8UOFYMBQUNCwgBCwABCwUBCwMCFwEAAGgUCwE4DgwGCgA3AAoGOFcMAwwCCwA3AQsGOFgMBQwECwILAwsECwUCGAEAAGlWCgA3CDgcAQwICgEKCCMECwsIDAEKADcIODIBDAcKAgoHJAQWCwcMAgoANwgLAThZDAEKADcICwI4WQwCQBQAAAAAAAAAAAwJQBQAAAAAAAAAAAwFCgEGAAAAAAAAAAAhBC8LAAELAwELCQsFAgoBCgIlBFMFNAoANwgKAQoDET44WgwEDQkKAUQUDQULBEQUCgA3CAsBOC4BDAYKBgYAAAAAAAAAACEEUAsAAQsDAQVTCwYMAQUvCwkLBQIZAQAAaVYKADcCOBwBDAgKAQoIIwQLCwgMAQoANwI4MgEMBwoCCgckBBYLBwwCCgA3AgsBOFkMAQoANwILAjhZDAJAFAAAAAAAAAAADAlAFAAAAAAAAAAADAUKAQYAAAAAAAAAACEELwsAAQsDAQsJCwUCCgEKAiUEUwU0CgA3AgoBCgMRPjhaDAQNCQoBRBQNBQsERBQKADcCCwE4LgEMBgoGBgAAAAAAAAAAIQRQCwABCwMBBVMLBgwBBS8LCQsFAhoAAABqMQsACwE4VRADDAYGAAAAAAAAAAAMAwoGOB4MBQoFOCkgBCsFDwoGCgU4HxQ4IQwECgQQBRQKAiQEIgsDCwQQBBQWDAMFJAsEAQoGCwU4HxQ4KAwFBQoLBgELBQELAwIbAQAAax0LAjgODAUKADcHCwU4UwoBOE0UDAQKAQcbIwQTCwA3CAwDBRYLADcCDAMLAwsEOFUQAwsBOCECBgoGCwYCBQEEAgQFBAQEAQYHBgYGDQYABAAGBQYBBg4GCQYDBgQGCAQDBQAANQE1AjUINQk1CjULNQ01DjUPNRA1ETUSNRM1AARtYXRosQKhHOsLBgAAAAcBAAIDAg8FEQ8HIB0IPSAGXRwMeZgBAAEAAgABAAADAAIAAAAAAgACAwMBAwIBAwIEBAMBBAQJZGl2X3JvdW5kBG1hdGgDbXVsCW11bF9yb3VuZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pAwgAypo7AAAAAAQQAMqaOwAAAAAAAAAAAAAAAAABAAADDQsANQwCCwE1DAMLAgsDGAcBGjQCAQEAAAQaCwA1DAMLATUMBAgMAgoDCgQYBwEZMgAAAAAAAAAAAAAAAAAAAAAhBBIJDAILAgsDCwQYBwEaNAICAQAABBwLADUMAwsBNQwECAwCCgMHADUYCgQZMgAAAAAAAAAAAAAAAAAAAAAhBBMJDAILAgsDBwA1GAsEGjQCAAdjcml0Yml02xyhHOsLBgAAAA4BAAYCBhwDIsIBBOQBNgWaAusBB4UEmQQInghABt4IeArWCTMLiQoEDI0K2REN5hscDoIcFA+WHAIADQErASwAAgYBAAAAAQYAAAAEAQQAAQMMAgcBBAECBAIAAB8AAQEEACoCAwEEABUCBAEEAB4CBQEEAB0CBQEEACQGBQEEACEGBQEEABoGAwEEACgGAwEEABMHAwEEABEGCAEEABAGAwEEACYJCgEEAAoJCwEEAAcGDAEEAAgGDAEEAA8BDQEGAA4BDQEEABIGAwEEAC0ODQEEABYPBAEEAAwQEQABBRoNAgcEAQYWFwIHBAEJHB4CBwQBDhMNAgcEAQ8TDQIHBgEVFQQCBwQBGxUDAgcEAR8AEwIHBAElHB0CBwQdEh0UHBQbFAIKFxQKChQKFxIICgcKFhQSChYSEwoGCgUKHhQBChgSGBQeEg4KGhIaFBkUGRIBBwgEAQsCAQkAAQYLAgEJAAEDAQECAwMCBgsCAQkAAwMHCwIBCQADCQACAQMCBwsCAQkAAwEJAAEHCQABBgkAAAQHCwIBCQADAwEDBgsCAQkAAwMBBAECAgMIAQELAwIJAAkBAgMLAAEJAAEGCwMCCQAJAQIGCwMCCQAJAQkAAQYJAQQBAwMDEAMDAwMDAgYIAQEBCAEDAwsAAQkAAwMDAwcLAwIJAAkBCQAJARADAwMDAwMDAwMBAwMGCAEDAwkAAgcLAwIJAAkBCQABCQEBBwkBAgsDAgMIAQsDAgMLAAEJAAIGCAEDAgICC0NyaXRiaXRUcmVlDEludGVybmFsTm9kZQRMZWFmBVRhYmxlCVR4Q29udGV4dANhZGQGYm9ycm93FGJvcnJvd19sZWFmX2J5X2luZGV4EmJvcnJvd19sZWFmX2J5X2tleQpib3Jyb3dfbXV0GGJvcnJvd19tdXRfbGVhZl9ieV9pbmRleARjbG9iE2NvdW50X2xlYWRpbmdfemVyb3MHY3JpdGJpdA1kZXN0cm95X2VtcHR5BGRyb3AQZmluZF9jbG9zZXN0X2tleQlmaW5kX2xlYWYdZ2V0X2Nsb3Nlc3RfbGVhZl9pbmRleF9ieV9rZXkLaW5zZXJ0X2xlYWYOaW50ZXJuYWxfbm9kZXMIaXNfZW1wdHkNaXNfbGVmdF9jaGlsZANrZXkGbGVhdmVzCmxlZnRfY2hpbGQObGVmdF9tb3N0X2xlYWYGbGVuZ3RoBG1hc2sIbWF4X2xlYWYIbWluX2xlYWYDbmV3GG5leHRfaW50ZXJuYWxfbm9kZV9pbmRleAluZXh0X2xlYWYPbmV4dF9sZWFmX2luZGV4BnBhcmVudA1wcmV2aW91c19sZWFmBnJlbW92ZRRyZW1vdmVfbGVhZl9ieV9pbmRleAtyaWdodF9jaGlsZA9yaWdodF9tb3N0X2xlYWYEcm9vdARzaXplBXRhYmxlCnR4X2NvbnRleHQMdXBkYXRlX2NoaWxkBXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMIAAAAAAAAAIADCP//////////Awj/////////fwACAxcDLgkAIwMBAgQcAxkDJwMjAwICBykDFAsDAgMIARgLAwIDCwABCQAeAx0DIAMiAwIKAAoAAwAADQsHCQoAOAALADgBBwkHCQYAAAAAAAAAAAYAAAAAAAAAADkAAgEDAAANBAsANwA4AgICAwAADQQLADcAOAMCAwMAAA0VCgA4BCAEBQUJCwABBwQnCgA3AAoANwEUOAU3AhQLADcBFAIEAwAADRUKADgEIAQFBQkLAAEHBCcKADcACgA3AxQ4BTcCFAsANwMUAgUBAAAYTgoACwE4BgwDAQoDBwkiBAoFDgsAAQcEJwcKCgMXDAUKADcACwM4BTcEFAwECgQHCSIEJAUeCgAKBAsFOAcMAgUmCQwCCwIEMgsEDAUKADcFCgU4CBAGFAwEBRkKBAcJIQQ7CwABBgAAAAAAAAAABwkCBwoKAAoANwULBDgIEAcUOAkXDAMLADcACgM4BTcCFAsDAgYDAAAYTwoACwE4BgwDAQoDBwkiBAoFDgsAAQcEJwcKCgMXDAUKADcACwM4BTcEFAwECgQHCSIEJQUeCgAKBAsFOAcgDAIFJwkMAgsCBDMLBAwFCgA3BQoFOAgQBhQMBAUZCgQHCSEEPAsAAQYAAAAAAAAAAAcJAgcKCgAKADcFCwQ4CBAIFDgKFwwDCwA3AAoDOAU3AhQLAwIHAAAAAxMLAQwCCgIHCSMEDwUHCgA3BQsCOAgQBxQMAgUCCwABCwICCAAAAAMTCwEMAgoCBwkjBA8FBwoANwULAjgIEAgUDAIFAgsAAQsCAgkDAAAZ9wEKAQsCBwk5AQwPCgA3BhQMEAoANwYUBgEAAAAAAAAAFgoANgYVChAHCwYBAAAAAAAAABcjBBgFHAsAAQcBJwoANgAKEAsPOAsKAAoBDAMuCwM4DAwHCgcHCSEERQoQBgAAAAAAAAAAIQQxBTULAAEHAicHCgoQFwoANgcVChAKADYBFQsQCwA2AxUGAAAAAAAAAAACCgA3AAsHOAU3AhQMBgoGCgEiBFEFVQsAAQcDJzFACwYKAR01ERUxQBcXDAgGAQAAAAAAAAALCDEBFy8MEQoRBwkHCQcJEgEMDAoANwgUDA0KADcIFAYBAAAAAAAAABYKADYIFQoANgUKDQsMOA0KADcHFAwSBwkMDgoSBwkjBKkBBYcBCgA3BQoSOAgMCQoRCgkQDBQkBJUBCwkBBakBCxIMDgoBCgkQDBQcBgAAAAAAAAAAIQSkAQsJEAcUDBIFqAELCRAIFAwSBYIBCg4HCSEEsgEKDQoANgcVBcEBCgAKDgoSDAUMBC4LBAsFOAcMCgoACw4KDQsKOA4LEQoBHAYAAAAAAAAAACEMCwoACg0HCgoQFwoLOA4KAAsNCxILCyA4DgoANwAKADcBFDgFNwIUCgEkBOMBChAKADYBFQoANwAKADcDFDgFNwIUCwEjBPMBChALADYDFQX1AQsAAQsQAgoDAAADGwoAOAQECAsAAQkHCQIKAAoBOAwMAgsANwAKAjgFNwIUCwEiBBgJBwkCCAsCAgsDAAADEgoAOAQEBwsAAQYAAAAAAAAAAAIKAAsBOAwMAgsANwALAjgFNwIUAgwDAAAbqwEKADcACgE4BTcCFAwMCgA3ARQKASEEGQoACgwMBC4LBDgPDAkBCwkKADYBFQoANwMUCgEhBCsKAAsMDAUuCwU4EAwKAQsKCgA2AxUKADYACgE4EToBDA8MEQEKAC44EgYAAAAAAAAAACEETgcJCgA2BxUHCQoANgEVBwkKADYDFQYAAAAAAAAAAAoANggVBgAAAAAAAAAACwA2BhUFqQEKDwcJIgRTBVcLAAEHBicKADcFCg84CAwOCg4QBhQMDQoACg8HCgsBFwwHDAYuCwYLBzgHBHELDhAIFAwIBXULDhAHFAwICwgMEAoNBwkhBJUBChAHCSMEhwEHCQoANgUKEDgTDwYVBZABBwkKADYABwoKEBc4FDYEFQsQCgA2BxUFpAEKAAoNCg8MAwwCLgsCCwM4BwwLCgALDQsQCws4DgsANgULDzgVAQsRAg0DAAANBgsANgALATgUNgkCDgMAAA0GCwA3AAsBOAU3CQIPAwAAAw4KAAsBOAYMAgQGBQoLAAEHBCcLAAsCOBYCEAMAAB8OCwA6AAEBAQEMAgwBAQsBOBcLAjgYAhEDAAAfFw4ANwA4AgYAAAAAAAAAACEEBwUJBgAAAAAAAAAAJwsAOgABAQEBDAIMAQELAjgZCwE4GgISAAAAIC4KADcHFAwDCgMHCSEEDAsAAQcJAgoDBwkjBCgFEQoANwULAzgIDAIKAQoCEAwUHAYAAAAAAAAAACEEIwsCEAcUDAMFJwsCEAgUDAMFDAsAAQcKCwMXAhMAAAANNwoBBwkiBAUFCQsAAQcHJwsDBBMKAgoANgUKATgTDwcVBRoKAgoANgUKATgTDwgVCgIHCSIENAoCBwkkBCwLAQsANgAHCgsCFzgUNgQVBTMLAQsANgULAjgTDwYVBTYLAAECFAAAAA0JCwA3BQsBOAgQBxQLAiECFQAAACFrCgAyAAAAAAAAAAAAAAAAAAAAACEEBzGADAEFaTEADAIKADIAAAAAAAAAAP//////////HDIAAAAAAAAAAAAAAAAAAAAAIQQXCwAxQC8MAAsCMUAWDAIKADIAAAAAAAAAAAAAAAD/////HDIAAAAAAAAAAAAAAAAAAAAAIQQlCwAxIC8MAAsCMSAWDAIKADIAAAAAAAAAAAAAAAAAAP//HDIAAAAAAAAAAAAAAAAAAAAAIQQzCwAxEC8MAAsCMRAWDAIKADIAAAAAAAAAAAAAAAAAAAD/HDIAAAAAAAAAAAAAAAAAAAAAIQRBCwAxCC8MAAsCMQgWDAIKADIAAAAAAAAAAAAAAAAAAADwHDIAAAAAAAAAAAAAAAAAAAAAIQRPCwAxBC8MAAsCMQQWDAIKADIAAAAAAAAAAAAAAAAAAADAHDIAAAAAAAAAAAAAAAAAAAAAIQRdCwAxAi8MAAsCMQIWDAILADIAAAAAAAAAAAAAAAAAAACAHDIAAAAAAAAAAAAAAAAAAAAAIQRnCwIxARYMAgsCDAELAQICAgIDAAACBAACAgEBAwEBAQICBgIAAgUBAAABAAoBCgIKAwoECgUKCQoKCgsKDQoACwAJY3VzdG9kaWFu2wyhHOsLBgAAAA4BAAwCDDADPKQBBOABHgX+AfYBB/QDwAQItAhABvQICgr+CCYLpAkEDKgJ4AINiAwIDpAMBg+WDAIAFwEPARUBIwElASYAAAQBAAEAAQwAAAQMAQABAQIEAQABAgMMAQABAwUHAAMIBAAEBgwCBwEEAQUHAgAAIQABAAAKAgMBAAAiAAQBAAAqBQYBAAArBQYBAAAcBwgBAAAYCQoBAAAdCwgBAAAZDAoBAAAfCQgBAAAoDAgBAAAJAg0BAAAMAg0BAAATDg8BAAARAhABAAEeGg0BAAEkHQoBAAEpFw0BAAEsCAoBAAIaGQYBAAMiABEAAycbHAAEDR8IAgcEBBAVFgIHBAQSICECBwQEFhUeAgcEBCIAGAIHBBcUERMaFAYTExMNEw8TEBMHEwgTBRMZFBITFhQYFAEHCAgBCAECBgsCAQkACAUCAwMBCwIBCQAEBwsCAQkAAwYIAQcICAELBAEJAAMHCwIBCQAIBQsDAQkAAAMHCwIBCQAGCAEDAQsDAQkAAwcLAgEJAAYIAQsDAQkAAwcLAgEJAAgFAwEDAgcLAgEJAAgFAQcLAAEJAAEGCwABCQABCAYDBgsAAQkAAwMBCQACCAULAAEJAAIGCwcCCQAJAQkAAQYJAQEGCwMBCQABCwcCCQAJAQILAwEJAAcICAIHCwMBCQALAwEJAAEGCAYBCAUCBwsDAQkAAwEBAwcLBwIJAAkBCQAJAQIHCwcCCQAJAQkAAQcJAQdBY2NvdW50CkFjY291bnRDYXAHQmFsYW5jZQRDb2luCUN1c3RvZGlhbgJJRAVUYWJsZQlUeENvbnRleHQDVUlEGWFjY291bnRfYXZhaWxhYmxlX2JhbGFuY2UPYWNjb3VudF9iYWxhbmNlEGFjY291bnRfYmFsYW5jZXMWYWNjb3VudF9sb2NrZWRfYmFsYW5jZQNhZGQRYXZhaWxhYmxlX2JhbGFuY2UHYmFsYW5jZQZib3Jyb3cWYm9ycm93X2FjY291bnRfYmFsYW5jZQpib3Jyb3dfbXV0GmJvcnJvd19tdXRfYWNjb3VudF9iYWxhbmNlBGNsb2IEY29pbghjb250YWlucwljdXN0b2RpYW4fZGVjcmVhc2VfdXNlcl9hdmFpbGFibGVfYmFsYW5jZRxkZWNyZWFzZV91c2VyX2xvY2tlZF9iYWxhbmNlDGZyb21fYmFsYW5jZQJpZB9pbmNyZWFzZV91c2VyX2F2YWlsYWJsZV9iYWxhbmNlHGluY3JlYXNlX3VzZXJfbG9ja2VkX2JhbGFuY2UEam9pbgxsb2NrX2JhbGFuY2UObG9ja2VkX2JhbGFuY2UQbWludF9hY2NvdW50X2NhcANuZXcGb2JqZWN0BXNwbGl0BXRhYmxlCnR4X2NvbnRleHQMdWlkX3RvX2lubmVyDnVubG9ja19iYWxhbmNlBXZhbHVlE3dpdGhkcmF3X2Jhc2VfYXNzZXQUd2l0aGRyYXdfcXVvdGVfYXNzZXQEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAEAAAAAAAAAAAICDgsDAQkAIAsDAQkAAQIBGwgGAgICGwgGCwsHAggFCwABCQACEwATAAEAAAgECwARFBIBAgEDAAASEAsANwALATgADAIKAjcBOAEMAwsCNwI4AQwECwMLBAICAwAACAYKABEUCwA4AjkAAgMDAAAIBwsACwILATgDCwM4BAIEAwAACAcLAAsCCwE4AwsDOAQCBQMAAAgICwALATgFNgELAjgGAQIGAwAACAkLAAsBEAMRFTgFNgELAjgHAgcDAAAICgsACwEQAxEVOAU2AgsCOAYBAggDAAAIBwsACwE4BTYCCwI4BwIJAwAACgoKAAoBCwI4AwwDCwALAQsDOAgCCgMAAAoKCgAKAQsCOAkMAwsACwELAzgKAgsDAAAIBwsANwALATgANwE4AQIMAwAACAcLADcACwE4ADcCOAECDQAAAAgSCgA3AAoBOAsgBA0KADYACgE4DDgMOQE4DQsANgALATgOAg4AAAAIDwoANwAKATgLBAYFCgsAAQcAJwsANwALATgAAgIBAAAAAQEAABMBEwITABQADQljdXN0b2RpYW4HQWNjb3VudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pCWN1c3RvZGlhbgpBY2NvdW50Q2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukJY3VzdG9kaWFuCUN1c3RvZGlhbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pB2NyaXRiaXQETGVhZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pB2NyaXRiaXQMSW50ZXJuYWxOb2RlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukHY3JpdGJpdAtDcml0Yml0VHJlZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pBGNsb2ILUG9vbENyZWF0ZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QRjbG9iC09yZGVyUGxhY2VkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukEY2xvYg1PcmRlckNhbmNlbGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukEY2xvYgtPcmRlckZpbGxlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pBGNsb2IFT3JkZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QRjbG9iCVRpY2tMZXZlbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pBGNsb2IEUG9vbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3JfY2FwH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAAAQAAAAAAAAAAQAB6m7J/DqSin0O78BL2X7p2wadLu9VHLQZenFeb3kNT7jVL4xqhzJpt7/k0yHfLDJvMAQYVZAeoSdHGasv23IwA7jVL4xqhzJpt7/k0yHfLDJvMAQYVZAeoSdHGasv23IwAAAEBAAAAAAAAAAAoBwnRr+4OFRx+9xpBP6AJklpKh6LPY0JTdxSt8dX+e9UAAENP15RqAAB7gyC3+hQw3PBZTqueIMXSiSbGrSFnT7J7B9e7Z4tH0QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wVUG9vbFRva2VuRXhjaGFuZ2VSYXRlAAAAAAAAAAAAADgJgyQCqIyQRy+mY2liaJT9XLzkvpaHnGw4Qij0ZLKSrwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQ9uAKu8Ui2h+FQIIoP7VHDM12ouG7gzh/2tXiexRDYAAAAQEAAAAAAAAAACgP1D99bZcbZxmGrfRoQc8o259Qr7C4O7rIT8oeB9qL/gAAQ0/XlGoAAEm6oy6kC0WlSQRKpDvVmSEvth0cl5DGNK9TnBwox9nbAAABAQAAAAAAAAAAKCEZKPioHQ6EK4IiUcJ2Izh65HrwDnMxA28tLtjn6Q3OAABDT9eUagAAe4Mgt/oUMNzwWU6rniDF0okmxq0hZ0+yewfXu2eLR9EAAAEBAAAAAAAAAAAoMEoY/4TSSDrtbdQFsnddu/i0vGYtST5T1Scm43rGdeIAAENP15RqAABJuqMupAtFpUkESqQ71ZkhL7YdHJeQxjSvU5wcKMfZ2wAAAQEAAAAAAAAAACg3wp7Ck8MlTWpxp7GXiccinMajVwLZRHXcIoS8UO5OewAAQ0/XlGoAAA0PBMs887515Y/9UZvSiCITFTbuMmwAfBPaR6cAnhQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX2NhcB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwAAEAAAAAAAAAAEBCsDx7L8K+gWjtx/EP+rtuYWR86pOMKzz58OWFnTKsJ2swbQww+L6NZtj1wibPCFcCRPBJ/Kd+mybJY5X5JRsSAGswbQww+L6NZtj1wibPCFcCRPBJ/Kd+mybJY5X5JRsSAAABAQAAAAAAAAAAKEo15hxpcX9gdgTVKPsZFcOwRXoHdvZsSS7BRpGG4NZ9AABDT9eUagAAtqGXTARPET/4NEhSJPrRIEHWQXOsaeobUpmOqmJRVi8AAAEBAAAAAAAAAAAoTOIyzQIJW6UJ1mmWUPER0Doz15id5dsSaCpvuigVK64AAENP15RqAABJuqMupAtFpUkESqQ71ZkhL7YdHJeQxjSvU5wcKMfZ2wAAAgAAAAAAAAAAAFBRKdl9Yt19UpGKCsmRSlDWhiQ3V8hUvA+NClz44p+gkeI0jXDjbx6aK976Je9kNGE85R4sU4I2M+QXJn6zBfXvAAAAAAAAAAAAAILf5A1HAABrMG0MMPi+jWbY9cImzwhXAkTwSfynfpsmyWOV+SUbEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdAJJRAAEAAAAAAAAAAAAYGB8ixQ1hNYIHBXqe9dADEimGtscnuYPPSoi7+HkkyUQtGV/WGQmZmM5afZqPb0zLkWfR3MjDRMsndwU8Si30PjuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjAEflfs97OKS9sv1olKzUyE89S6NfxKSRne06ngc38eeOgAAAQEAAAAAAAAAAChhtRNPzqDAFsnRbax9s8EBJ5UgmNN1OdDc4nwk0Q+4bwAAQ0/XlGoAALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAICBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXITU3VpU3lzdGVtU3RhdGVJbm5lcgAAAAAAAAAAAACfGmryorfKYL92F0rf0+nElX+Ok3dZYDGC+bRsf2xfGcbSAQAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAQAAAAAAAAAAAAh+kzccAQQdlqGWc4hYr9v2AUTi0cWqjRDVpFw3WhCtgvkiAFE0GmCNz/bRVQQKZW9IGbExEbUsV0aoa6cvOV+6/i7DhH0egUDmJKdR/fa18gULxyBc+dMABMkLDHQK/9Mmzmc8wrI6LSTVPir+sobfxmj9QGAInW0rF7eZ3Tb5DTMuVKejONQgXw9Cyz+yDdV3cDOIMglk+TUdmXMTwEoDIkcGDSFLLnEgNzcStuIbnPffsBHiunWHMc4LcUlzICVo1U95+8yxd0kwiyzWtDylvqPLC+t6rUZeJFE6XLu39wLim2VBbz6NAb3a9tiL09BgKVbugWjBAwqkC3ZhbGlkYXRvci0xAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zMzM1NS9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC80NjMzNRgvaXA0LzEyNy4wLjAuMS91ZHAvNDIwMzkYL2lwNC8xMjcuMC4wLjEvdWRwLzM5ODU5AAAAAAAAAAAHILRUHKflqCQ6XlUQIcvq3QMXSSZwaCnEEUgkkENUsQAAAAAAAAAAxAkAAAAAAACTUVVPz8b4Xk1FkdnT000IXQ4QZNveyI+mLkBEzvWKyugDAAAAAAAAKy99JiJBKTD5NRW3IWxgJIMbYO1PHb7BK6zx6IKb7MgBAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAk8OcOHHTZYqWVqUUx83pyU4uLCAM8PPRW5Mg+VhHpX4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyX/uAqGGEFaDV6mBiFQEslfqFrHjwiD4Ip+CIUUS9kAAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAAEcs98D4eYltE4bUFz9hTqzOoO+B21sTPFiPFEzAULNyAAAAAAAAAADuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjGCZ8l72H4AyuRRjZGCYLFzG8TTvHdrnZlfyy/7B6/yNCXN0CA32/PDcuLxLDY4K9dgOu/8rTFmfVPQtYxLfwxQnYHjBzDR+u77FGYviWFE/OGuTDQLCdJqAPiMwlV69GhAgzmDjB34Co2g0Nq9FDzpFEbTECxWJVmN8r5zPETkefhAgEWzsBHlYiAE3N5D0DGMCQVlkWIKcTt9IlzeiMQ0CFtwwi4uTNREZbHVnSkLgGmQBE40j2XtrTtF/mCMsCsMrnHONz/ga9tRpQKesAW2h857NC3ZhbGlkYXRvci0wAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zNjQ1OS9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC80NDA2MRgvaXA0LzEyNy4wLjAuMS91ZHAvMzY3NDUYL2lwNC8xMjcuMC4wLjEvdWRwLzM5NDEzAAAAAAAAAAAqj9QggOfSzl4V+GoGupp0zLLjFK7Ai/kU14Z0pcplwgAAAAAAAAAAxAkAAAAAAAAAepuyfw6kop9Du/AS9l+6dsGnS7vVRy0GXpxXm95DU+gDAAAAAAAAtGV/WGQmZmM5afZqPb0zLkWfR3MjDRMsndwU8Si30PgBAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAdk7bK8RROD8dpsPXdTNoXuGWH148/rlAHPlcYlgMuhsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOALCrjh1OlDO9wp3K37FsmQUyK0Z+1veXMy6WoD6PPpAAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAAMCoc8pdZWPKGUV6q+J5JXMc4SlHoBErQiqd4mV0fA7zAAAAAAAAAACRzKvCogqNa1yKYBCVcquLQ2r6tbMDzoDk8W3A3kTxCWCt3u+U2JjIjkDb3v+RxfEF+c8sdH+28rw37APWyR7bLhpXjPVEvosJMeJfJD1ZsMMNmKFs47odbPHX9QQmmS6wrbMTSwVb6BQNLbXyX7ANg/jkIivwH9ask6H/TXnaWPIgbZCVEwsVNsDJIY6p/rDzZoWm+gs7HmfSVsxPs0CkjWkg4aJsYZ6zZso+y9AJsSdyVwZpvS5xBIkFkHq/P1vVicAwg54KGo44DGyw4IzRjcWLzbg6Jk6yWiOvJMf7BMOaTNaad3ggvrve/e4nm6wmN8RBC3ZhbGlkYXRvci0yAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zNDYzMy9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC8zMjk2NRgvaXA0LzEyNy4wLjAuMS91ZHAvMzU0NTcYL2lwNC8xMjcuMC4wLjEvdWRwLzM4Nzc3AAAAAAAAAABTNhzYGW9m5KkSFn9ArSMiPdKVXpJY3m2tPt4e9IrJagAAAAAAAAAAxAkAAAAAAAB4lQ80jeOmoKV/UC9hBPicN/10aUq5MV0cEovDw1a5ZOgDAAAAAAAA6acBh9L1XSJ3yoBV6dqFMrxVeE0xtplrp4+c1CltCD4BAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAsKJKXbPSW1XP7jTBDgMK2GrtaGaWY4MGkj4hEakxfIQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGgWz9PGeUN9QEyThBHsL0qqjU3+ySOilTRettQOhqr+AAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAANQQ3CSl/J897uufZyU7yE/TheAJXn18ZUcAhNz0IoB9AAAAAAAAAABrMG0MMPi+jWbY9cImzwhXAkTwSfynfpsmyWOV+SUbEmCz/V77XIckA6StE/EZlRNgbSM1SoRSSa6hV1ZMI/88FcbJ5lK3LXQOjKy5PLzAaGsOwMwMHHYL+0K0NlGfxagFS3ZTOpep8jmH0JfvlrHyUmuyBz+hCncZlBdyNH7ydPQgspFb94eEWlXCThj9wWKldesC0juuP55WbXxR68/rSkIg8kw7zFaMQz00lCDtKETmq8+h3WPHxOET+m/+d8OLN5cwjH1jRasTAwXh522c5CGYCtEP3OL4+3AftEv/V5VTo84aM98Vcq7RvxQRQNNvdRjFC3ZhbGlkYXRvci0zAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zMzk1My9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC8zOTg4ORgvaXA0LzEyNy4wLjAuMS91ZHAvMzgxNzUYL2lwNC8xMjcuMC4wLjEvdWRwLzM0NjU1AAAAAAAAAAB5Bga3JMoC4IzRoFv5/VtYTjXap+MAb9AY/b0XUvqcEgAAAAAAAAAAxAkAAAAAAABCsDx7L8K+gWjtx/EP+rtuYWR86pOMKzz58OWFnTKsJ+gDAAAAAAAA4jSNcONvHpor3vol72Q0YTzlHixTgjYz5BcmfrMF9e8BAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAEPbgCrvFItofhUCCKD+1RwzNdqLhu4M4f9rV4nsUQ2ABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA960Qi0S0U6BDq5/IpdoN9qCAL0Mtadv9qsbqs0kX43AAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAALXy8lsznanogWAJQdi8BJRveAbXZAU0khL0/RuSvMUlAAAAAAAAAADyDLlENgEFhcdiENKB4e7ewpnQ11c5Rq+IXbCiPkqX5wAAAAAAAAAAAB+V+z3s4pL2y/WiUrNTITz1Lo1/EpJGd7TqeBzfx546BAAAAAAAAAD05hHSH05rAHQinJqI2qlgmwDYW0Ar1ZUlKvAb1YO3/AAAAAAAAAAAme3BiKhIlx5YejQ6LP0fUAchBVxU5UQnLbIE5YzOhjoAAAAAAAAAAAD8MKYtNUf67vuKdE6P5oQ1FIAoRKku2yiTHCg7VYAmMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcJgUAAAAAAAAAAAAAAACWAAAAAAAAAAAAQ0/XlGoAAACC3+QNRwAAgKGna0o1AAcAAAAAAAAAHYs50dCPQ6ybhPyI0uSJq3qb5mDjI+lgzdtX3nxAfZ4AAAAAAAAAAOgDAAAAAAAAAAAAVU5qYkJ/AAAAAAAAAAAAgMakfo0DAB4AAAAAAAAAECckK9UFd0RjYpGX8B3DEoyR+9yoxKKlGpdtNOBIobrHiQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyjYfxIcBAAAV2oCN7dMGWG9VQgN8pL4hchVVXQwtTLf/u3XRt82O5gAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGb2JqZWN0AklEAAQAAAAAAAAAAABgb0rk3QYBsEj0pF/BkzjEOSYlmBlF2nAEWrD4jmJlJ+TppwGH0vVdInfKgFXp2oUyvFV4TTG2mWunj5zUKW0IPpHMq8KiCo1rXIpgEJVyq4tDavq1swPOgOTxbcDeRPEJAR+V+z3s4pL2y/WiUrNTITz1Lo1/EpJGd7TqeBzfx546AAABAQAAAAAAAAAAKHKx8DBUNkciLx+XTdI3LScK3Siwiq8cMBOPiOeR0rh3AABDT9eUagAA7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3JfY2FwH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAAAQAAAAAAAAAAQHiVDzSN46agpX9QL2EE+Jw3/XRpSrkxXRwSi8PDVrlkkcyrwqIKjWtcimAQlXKri0Nq+rWzA86A5PFtwN5E8QkAkcyrwqIKjWtcimAQlXKri0Nq+rWzA86A5PFtwN5E8QkAAAEBAAAAAAAAAAAof9z54bG0U9spRw6CuIsOitWyfryr8yVXhnO0jjxEdTIAAENP15RqAAANDwTLPPO+deWP/VGb0ogiExU27jJsAHwT2kenAJ4UIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wVUG9vbFRva2VuRXhjaGFuZ2VSYXRlAAAAAAAAAAAAADiDz6sfwEs6e6UFCaJh56GmqbY2OlHw1RiI7jYOR4lecwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF2TtsrxFE4Px2mw9d1M2he4ZYfXjz+uUAc+VxiWAy6GwAAAgAAAAAAAAAAAFCD1k5PxPNdgUPU8A5P0F0T6TLQG53sFFWq/UuWbxuQA+mnAYfS9V0id8qAVenahTK8VXhNMbaZa6ePnNQpbQg+AAAAAAAAAAAAAILf5A1HAACRzKvCogqNa1yKYBCVcquLQ2r6tbMDzoDk8W3A3kTxCQAAAgAAAAAAAAAAAFCOslZQFQKLoOsYxUKJEEN4XruGB7gl4GZ2LPZxvoRX7LRlf1hkJmZjOWn2aj29My5Fn0dzIw0TLJ3cFPEot9D4AAAAAAAAAAAAAILf5A1HAADuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9jYXAfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAABAAAAAAAAAABAk1FVT8/G+F5NRZHZ09NNCF0OEGTb3siPpi5ARM71isodlqGWc4hYr9v2AUTi0cWqjRDVpFw3WhCtgvkiAFE0GgAdlqGWc4hYr9v2AUTi0cWqjRDVpFw3WhCtgvkiAFE0GgAAAQEAAAAAAAAAACiUHTR/XH5fbwyHvE1TeYoyKoXPuds/c+6AmN2EQAvwSQAAQ0/XlGoAALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYvAAABAQAAAAAAAAAAKJ/7yi7mbq/m1ZAvKcsKhNsxPcm1SkQYo2h7OSGm2bsCAABDT9eUagAADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCAAAAEBAAAAAAAAAAAoowF6v6fXTNgUKRMLWFp/vxhF6OFbgNXYnL5lqOhTv0UAAENP15RqAABJuqMupAtFpUkESqQ71ZkhL7YdHJeQxjSvU5wcKMfZ2wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBGNvaW4MQ29pbk1ldGFkYXRhAQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNzdWkDU1VJAAEAAAAAAAAAACulo9wBjqkC8AGuUEQlGdMOdmYxqXFPMJtJfaj6xSSanQkDU3VpA1NVSQAAAwAAAQEAAAAAAAAAACitUotCmNKFPIwUlrpLVnY1F86LElAt2Y+y4goD3IcMmwAAQ0/XlGoAAHuDILf6FDDc8FlOq54gxdKJJsatIWdPsnsH17tni0fRAAABAQAAAAAAAAAAKLQBvSjHw4eZ0wG+8gpJmO9MB+29FWXUh/+rE7+6hpRjAABDT9eUagAASbqjLqQLRaVJBEqkO9WZIS+2HRyXkMY0r1OcHCjH2dsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZvYmplY3QCSUQABAAAAAAAAAAAAGC1MJTIzFY4NvYcAOq40vVWuAJG9eQp/7hprGpOG1wz1+I0jXDjbx6aK976Je9kNGE85R4sU4I2M+QXJn6zBfXvazBtDDD4vo1m2PXCJs8IVwJE8En8p36bJsljlfklGxIBH5X7PezikvbL9aJSs1MhPPUujX8SkkZ3tOp4HN/HnjoAAAEBAAAAAAAAAAAowBx1aADkhKVJTlY2EpBTY9hsurCmQ8n29ubfYagI85IAAENP15RqAAANDwTLPPO+deWP/VGb0ogiExU27jJsAHwT2kenAJ4UIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdAJJRAAEAAAAAAAAAAAAYMf2wVcsuwFijHhbr+a98vGOgvplAtbqgTDzFUKsUF3tKy99JiJBKTD5NRW3IWxgJIMbYO1PHb7BK6zx6IKb7MgdlqGWc4hYr9v2AUTi0cWqjRDVpFw3WhCtgvkiAFE0GgEflfs97OKS9sv1olKzUyE89S6NfxKSRne06ngc38eeOgAAAQEAAAAAAAAAACjNTjbpEa5n6Z6lsDppQZByGyh6FJsoBAfGQESiqtLaugAAQ0/XlGoAAO2GcxXj98g66C5tWFi2psxXwpH9hPdQlkbryBYhac+WAAABAQAAAAAAAAAAKNKQI/yGML5+UrcwNODD/znzdiVrEcFIwPl1jImERDGLAABDT9eUagAA7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5YAAAEBAAAAAAAAAAAo1T22lKKDRmTdLP9D/wB6NDk4msdNiPXZdaEsMfwgyMkAAENP15RqAAC2oZdMBE8RP/g0SFIk+tEgQdZBc6xp6htSmY6qYlFWLwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wVUG9vbFRva2VuRXhjaGFuZ2VSYXRlAAAAAAAAAAAAADjWGyj7IpNTLEYSK13Xfkml+I1vcz5xoMsRrGb+jlm/8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGwokpds9JbVc/uNMEOAwrYau1oZpZjgwaSPiERqTF8hAAAAQEAAAAAAAAAACjbGg3kdS1Q/ZRxOkXtF5b6nZkMTlEctSFegndMluacrQAAQ0/XlGoAAA0PBMs887515Y/9UZvSiCITFTbuMmwAfBPaR6cAnhQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAICBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbBVQb29sVG9rZW5FeGNoYW5nZVJhdGUAAAAAAAAAAAAAONs2AkoAkytfpTPHVDBEzxI4VXQDI0RtOHAbYsKjKMN5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZPDnDhx02WKllalFMfN6clOLiwgDPDz0VuTIPlYR6V+AAABAQAAAAAAAAAAKN+Z5K7+QFhNp0EMDPe0fkc5ciqr9vp3MANEd6hvuWJuAABDT9eUagAAe4Mgt/oUMNzwWU6rniDF0okmxq0hZ0+yewfXu2eLR9EAAAEBAAAAAAAAAAAo4P3dPuRkdqB3a5GWQ1DY7gcnzUUTcE2dRnPz/E34UDwAAENP15RqAAC2oZdMBE8RP/g0SFIk+tEgQdZBc6xp6htSmY6qYlFWLwAAAQEAAAAAAAAAACjs7bZBm5EQ3apNFF9D04M2S9a1nowGcPhgUg0g6gaYLwAAQ0/XlGoAAO2GcxXj98g66C5tWFi2psxXwpH9hPdQlkbryBYhac+WAAABAQAAAAAAAAAAKO6xodBEIKA4CT/RgTexRuZLKamQ425++rBXsm6Bn8lSAABDT9eUagAA7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5YAAAIAAAAAAAAAAABQ92Ycv2dxXLpW8bw0qDukz8Ya/gPCpL+Oz6UpZdcLJRkrL30mIkEpMPk1FbchbGAkgxtg7U8dvsErrPHogpvsyAAAAAAAAAAAAACC3+QNRwAAHZahlnOIWK/b9gFE4tHFqo0Q1aRcN1oQrYL5IgBRNBoAAAEBAAAAAAAAAAAo+d1INR0JTR3V0tZZ6ugXDm72dmAfv2VMmStny60fHggAAENP15RqAAB7gyC3+hQw3PBZTqueIMXSiSbGrSFnT7J7B9e7Z4tH0QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAWEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAACDjcqtN5pwo5Nb1c6ks1QUqmoEZru8Ws5JPg1Hn3raaAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEAAAAAAAAAICel0DjkNZtMFRZv7rqp/JU41pYiJFBjPxSJJAxIw9caAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAQAAAAAAAAAgwjWmbRXIqdbkPWy7T8uSoKvnlNgzSuu8CQ3k2FYjr7MDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUBAAAAAAAAACCTJRzh97r6QVZnvkDY/YdPxyF7aSvKleIw1VbMhXKUvwIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAQAAAAAAAAAg8qT5uvuCJ4nIPk/mE/L0nhMNLUbjFROQ1ssPpJLhIkMCAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QEAAAAAAAAAIPWb9lpdCEgn3r0muvfRlIBZ+Zpzb0W7XluNNQ609wUlAwB6m7J/DqSin0O78BL2X7p2wadLu9VHLQZenFeb3kNTAQAAAAAAAAAg29Wei4gh/saFmNSdUhqf0F8Fym5uJATxRKdYKkSSOgoA7jVL4xqhzJpt7/k0yHfLDJvMAQYVZAeoSdHGasv23IwHCdGv7g4VHH73GkE/oAmSWkqHos9jQlN3FK3x1f571QEAAAAAAAAAINw6q+hLWxwiIuyLDVUHgyzA5c3brt8TPLl0oEWHCUu7AHuDILf6FDDc8FlOq54gxdKJJsatIWdPsnsH17tni0fRCYMkAqiMkEcvpmNpYmiU/Vy85L6Wh5xsOEIo9GSykq8BAAAAAAAAACA/WQ3kWsRwlLkNQCquk0NcDrdhGq6oDhpBfGjI1D3fpAEQ9uAKu8Ui2h+FQIIoP7VHDM12ouG7gzh/2tXiexRDYA/UP31tlxtnGYat9GhBzyjbn1CvsLg7ushPyh4H2ov+AQAAAAAAAAAgUXgGV6VFzZLBHHbgWbwgJ/rKzOkD4PEF4ihhBlBY8ekASbqjLqQLRaVJBEqkO9WZIS+2HRyXkMY0r1OcHCjH2dshGSj4qB0OhCuCIlHCdiM4euR68A5zMQNvLS7Y5+kNzgEAAAAAAAAAIPL0Qz+JlD5X1CYFeXIcVxmTkPwEx/FKBZlQTLUw0EyQAHuDILf6FDDc8FlOq54gxdKJJsatIWdPsnsH17tni0fRMEoY/4TSSDrtbdQFsnddu/i0vGYtST5T1Scm43rGdeIBAAAAAAAAACD2xePtIKth9kRN6aO++nJOrrqFJd4g/tEFjaa97Z0PxwBJuqMupAtFpUkESqQ71ZkhL7YdHJeQxjSvU5wcKMfZ2zfCnsKTwyVNanGnsZeJxyKcxqNXAtlEddwihLxQ7k57AQAAAAAAAAAgrnoS533yyZz/vHSupTrk2htWXPyzsl8iiDN6xk8PthUADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCBCsDx7L8K+gWjtx/EP+rtuYWR86pOMKzz58OWFnTKsJwEAAAAAAAAAIL2C6npy/nC2lumFdMhdab3/q93uhuVy87s4umFZ7+qvAGswbQww+L6NZtj1wibPCFcCRPBJ/Kd+mybJY5X5JRsSSjXmHGlxf2B2BNUo+xkVw7BFegd29mxJLsFGkYbg1n0BAAAAAAAAACDHAbW8ejeLdZ0Nmz+RINqZow/LOh38TFqsM9FR30zVfwC2oZdMBE8RP/g0SFIk+tEgQdZBc6xp6htSmY6qYlFWL0ziMs0CCVulCdZpllDxEdA6M9eYneXbEmgqb7ooFSuuAQAAAAAAAAAgTuvuKygRF1Xthw7uxjDqq6FNEveb7Fxf7IrwEIpbcgAASbqjLqQLRaVJBEqkO9WZIS+2HRyXkMY0r1OcHCjH2dtRKdl9Yt19UpGKCsmRSlDWhiQ3V8hUvA+NClz44p+gkQEAAAAAAAAAIPNPx311fuxSIfS1E0i0zBWtBwhRK5ZqqaK4e+5vF9iJAGswbQww+L6NZtj1wibPCFcCRPBJ/Kd+mybJY5X5JRsSYHyLFDWE1ggcFep710AMSKYa2xye5g89KiLv4eSTJRABAAAAAAAAACBDHG54hnZBfaPS1S16KcZ81WnsF/vLPqlxVAI2bsbVCgEflfs97OKS9sv1olKzUyE89S6NfxKSRne06ngc38eeOmG1E0/OoMAWydFtrH2zwQEnlSCY03U50NzifCTRD7hvAQAAAAAAAAAgGxqYt/IPremqIZbmslEBRZb6YTXXp9/5CoLbu2c2+cUAtqGXTARPET/4NEhSJPrRIEHWQXOsaeobUpmOqmJRVi9q8qK3ymC/dhdK39PpxJV/jpN3WWAxgvm0bH9sXxnG0gEAAAAAAAAAIHNF5f4hz8jlFU8iQ+W2B8pDL2r1R/gUjXyb6rVz5gIUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFb0rk3QYBsEj0pF/BkzjEOSYlmBlF2nAEWrD4jmJlJ+QBAAAAAAAAACA5oSmqaXyCr2QoE4+Jk2o/3A9eicMJPSxL5icSlWqUnwEflfs97OKS9sv1olKzUyE89S6NfxKSRne06ngc38eeOnKx8DBUNkciLx+XTdI3LScK3Siwiq8cMBOPiOeR0rh3AQAAAAAAAAAgZurQotONNbT7nHUBJH6KTnLEY97xsVvozr5HgXKVWzUA7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5Z4lQ80jeOmoKV/UC9hBPicN/10aUq5MV0cEovDw1a5ZAEAAAAAAAAAIP/cB/DPPVwioVsyxM5nxZ3uS2NoYm/NX+5uex9fINtuAJHMq8KiCo1rXIpgEJVyq4tDavq1swPOgOTxbcDeRPEJf9z54bG0U9spRw6CuIsOitWyfryr8yVXhnO0jjxEdTIBAAAAAAAAACA1a7ZCfI15YlTaMQO/daUlJNhuYNC4p7W9ou9AXAkk1QANDwTLPPO+deWP/VGb0ogiExU27jJsAHwT2kenAJ4UIIPPqx/ASzp7pQUJomHnoaaptjY6UfDVGIjuNg5HiV5zAQAAAAAAAAAgshSiHn8fu3XCVLVBhPpMTkp12/M0fS1Hd5GbmX/F7PQBdk7bK8RROD8dpsPXdTNoXuGWH148/rlAHPlcYlgMuhuD1k5PxPNdgUPU8A5P0F0T6TLQG53sFFWq/UuWbxuQAwEAAAAAAAAAIJ9v+RdIaU/4/aoNbdH8C4XCJN4C+7hkXYraZWU1BmkhAJHMq8KiCo1rXIpgEJVyq4tDavq1swPOgOTxbcDeRPEJjrJWUBUCi6DrGMVCiRBDeF67hge4JeBmdiz2cb6EV+wBAAAAAAAAACCuz244oX8bnTV7vpCBmXynRsSaK4ryAKRYlv9eOPl0CgDuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjJNRVU/PxvheTUWR2dPTTQhdDhBk297Ij6YuQETO9YrKAQAAAAAAAAAgtDd+w6MWTAW10L3q1RAPXWtAciKwLyTLF/Id5tvlaNoAHZahlnOIWK/b9gFE4tHFqo0Q1aRcN1oQrYL5IgBRNBqUHTR/XH5fbwyHvE1TeYoyKoXPuds/c+6AmN2EQAvwSQEAAAAAAAAAIGyvxtbb2r13ZpXrOIInpDV3NHhwnBEY/60ASFME/mOvALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYvn/vKLuZur+bVkC8pywqE2zE9ybVKRBijaHs5IabZuwIBAAAAAAAAACBQgwDjm3b61vAbTg9I2T0nQnCYlRkldbfE9FOEdBczEAANDwTLPPO+deWP/VGb0ogiExU27jJsAHwT2kenAJ4UIKMBer+n10zYFCkTC1haf78YRejhW4DV2Jy+ZajoU79FAQAAAAAAAAAg1iFCleW3z93Y7tAykNvkZl/BW0Ch3QFtXsydGmZUHlUASbqjLqQLRaVJBEqkO9WZIS+2HRyXkMY0r1OcHCjH2dulo9wBjqkC8AGuUEQlGdMOdmYxqXFPMJtJfaj6xSSanQEAAAAAAAAAIH8Zxjlh14TsKTeGDc0XVihHLinlgZWIWbCrUj4qJ2USA61Si0KY0oU8jBSWuktWdjUXzosSUC3Zj7LiCgPchwybAQAAAAAAAAAgwuzBOajNvIuvwI5pctW+HVeeWptHLPYjc4IjFM5zd38Ae4Mgt/oUMNzwWU6rniDF0okmxq0hZ0+yewfXu2eLR9G0Ab0ox8OHmdMBvvIKSZjvTAftvRVl1If/qxO/uoaUYwEAAAAAAAAAIO1otfFijkCfpJmkkaBxmWbF0DHlMtTCe7lnAnlp5bVaAEm6oy6kC0WlSQRKpDvVmSEvth0cl5DGNK9TnBwox9nbtTCUyMxWODb2HADquNL1VrgCRvXkKf+4aaxqThtcM9cBAAAAAAAAACDh5ltFTeTavE9iXt/+I71Ux0pFixIscS6+AYdmeh2zHwEflfs97OKS9sv1olKzUyE89S6NfxKSRne06ngc38eeOsAcdWgA5ISlSU5WNhKQU2PYbLqwpkPJ9vbm32GoCPOSAQAAAAAAAAAgObkup1OXZfFWCcTu0wTyHZUbxE7fQvHsBgiWlYv3QiAADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCDH9sFXLLsBYox4W6/mvfLxjoL6ZQLW6oEw8xVCrFBd7QEAAAAAAAAAIKoh0kQ0OGN7nF3KabRcouUqwISyh+dFfk8VWxBcYlVuAR+V+z3s4pL2y/WiUrNTITz1Lo1/EpJGd7TqeBzfx546zU426RGuZ+mepbA6aUGQchsoehSbKAQHxkBEoqrS2roBAAAAAAAAACCdrC+SASWACln2ZWCH89A+fercvwokJm9sM7MCsLqvGADthnMV4/fIOugubVhYtqbMV8KR/YT3UJZG68gWIWnPltKQI/yGML5+UrcwNODD/znzdiVrEcFIwPl1jImERDGLAQAAAAAAAAAgjeVPXClBdV7jadH4zZ0yscEKJxzCLSsS8FO7jSPPnw0A7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5bVPbaUooNGZN0s/0P/AHo0OTiax02I9dl1oSwx/CDIyQEAAAAAAAAAILSoSOvSAdEgY4nH5zJ0FW4vOXrmlxq5UsdQID0ezse5ALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYv1hso+yKTUyxGEitd135JpfiNb3M+caDLEaxm/o5Zv/EBAAAAAAAAACDh1Scv5MF+zS+Kp1swwXN3TluiE/6zlrLg6QcpiuRkWQGwokpds9JbVc/uNMEOAwrYau1oZpZjgwaSPiERqTF8hNsaDeR1LVD9lHE6Re0XlvqdmQxOURy1IV6Cd0yW5pytAQAAAAAAAAAgZ4tBj7oADXapSWZzh8xPJaRD602p/X7REJKUcwmYYIMADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCDbNgJKAJMrX6Uzx1QwRM8SOFV0AyNEbThwG2LCoyjDeQEAAAAAAAAAIA4hvOtvNvLuGmKAYpTNBF4c3h6EWGMC9YhcgYzARI/sAZPDnDhx02WKllalFMfN6clOLiwgDPDz0VuTIPlYR6V+35nkrv5AWE2nQQwM97R+RzlyKqv2+ncwA0R3qG+5Ym4BAAAAAAAAACA71ZURncD/L8tqSHrlcUeig0kfuFQeOFxTeI+fkpXCLAB7gyC3+hQw3PBZTqueIMXSiSbGrSFnT7J7B9e7Z4tH0eD93T7kZHagd2uRlkNQ2O4HJ81FE3BNnUZz8/xN+FA8AQAAAAAAAAAgFtaEibIOehaz8j3S+Pj1TS/6wouMp3adnAh5TFib+KoAtqGXTARPET/4NEhSJPrRIEHWQXOsaeobUpmOqmJRVi/s7bZBm5EQ3apNFF9D04M2S9a1nowGcPhgUg0g6gaYLwEAAAAAAAAAIHkQyGA3pPFPi8r1degkioJSfriLIQR8FrqMat2FonurAO2GcxXj98g66C5tWFi2psxXwpH9hPdQlkbryBYhac+W7rGh0EQgoDgJP9GBN7FG5kspqZDjbn76sFeyboGfyVIBAAAAAAAAACBehUyclb13bZ/hDXvPcTzaP7FfsvjyqhR9Ha/QJHzPhQDthnMV4/fIOugubVhYtqbMV8KR/YT3UJZG68gWIWnPlvdmHL9ncVy6VvG8NKg7pM/GGv4DwqS/js+lKWXXCyUZAQAAAAAAAAAgVRyYKBL2Gw8IaMwkVMUcXUJBdBTFhN8dm6ODKi9ENd0AHZahlnOIWK/b9gFE4tHFqo0Q1aRcN1oQrYL5IgBRNBr53Ug1HQlNHdXS1lnq6BcObvZ2YB+/ZUyZK2fLrR8eCAEAAAAAAAAAINC7DyYr5O+gLOJ1KwB+qwyC+JGqEl0dO6m/kUEc0UpBAHuDILf6FDDc8FlOq54gxdKJJsatIWdPsnsH17tni0fRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAAAAAAAACwNiY3NcoRzrCwYAAAAGAQACAwIGBQgHBw8NCBwgDDwEAAAAAQABAQABBgkAAQoCA2Jjcwh0b19ieXRlcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAECAAAEaGFzaGqhHOsLBgAAAAYBAAIDAgoFDAMHDxcIJiAMRggAAAABAAAAAAIAAAABCgIEaGFzaAhzaGEyXzI1NghzaGEzXzI1NgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAECAAEBAgAABWFzY2lplwahHOsLBgAAAAsBAAQCBA4DElQEZggFbjsHqQHIAQjxAiAGkQMKCpsDCwymA7oCDeAFBAAFABAAAgcAAAAHAAEBBwEAAAAIAAEAABQCAwAAFQIEAAADBQYAABIHCAAAEQkBAAAOBQoAAAQFCwAACgMCAAAGAQAAAA0ABgAACwAGAAEJDQ4BAAEMDAYBAAEPCA0BAAETDg0BAA0DDAMOAw8DAQIBCAEBCgIBCAABCwIBCAABBggAAQECBwgACAEAAQcIAAEDAQYKAgEGCwIBCQABCwIBCQABCQACAwMEQ2hhcgZPcHRpb24GU3RyaW5nGGFsbF9jaGFyYWN0ZXJzX3ByaW50YWJsZQhhc19ieXRlcwVhc2NpaQRieXRlBWJ5dGVzBGNoYXIMZGVzdHJveV9zb21lCmludG9fYnl0ZXMRaXNfcHJpbnRhYmxlX2NoYXIHaXNfc29tZQ1pc192YWxpZF9jaGFyBmxlbmd0aARub25lBm9wdGlvbghwb3BfY2hhcglwdXNoX2NoYXIEc29tZQZzdHJpbmcKdHJ5X3N0cmluZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAEAAAAAAAACAQcKAgECAQYCAAEAAAgJCgARCgQEBQYHACcLABIBAgEBAAAEDAsAEQIMAQ4BOAAEBwUJBwAnCwE4AQICAQAADx4OAEEADAIGAAAAAAAAAAAMASgKAQoCIwQZBQsOAAoBQgAUEQogBBQ4AgILAQYBAAAAAAAAABYMAQUFKAsAEgA4AwIDAQAADyAKABAAQQAMAgYAAAAAAAAAAAwBKAoBCgIjBB0FDAoAEAAKAUIAFBELIAQYCwABCQILAQYBAAAAAAAAABYMAQUGKAgCBAEAAAgHCwAPAA4BEAEURAACBQEAAAgFCwAPAEUAEgECBgEAAAgECwARB0EAAgcBAAAIAwsAEAACCAEAAAgDCwATAAIJAQAACAMLABMBAgoBAAAIBAsAMX8lAgsBAAAGDQoAMSAmBAkLADF+JQwBBQsJDAELAQIAAAEAAAVkZWJ1Z3ShHOsLBgAAAAYBAAIDAgsFDQUHEh4IMCAMUAgAAAABAAEBAAACAQEAAQYJAAAFZGVidWcFcHJpbnQRcHJpbnRfc3RhY2tfdHJhY2UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQABAgABAQIAAAZvcHRpb27xCKEc6wsGAAAADQEABAIEBgMKeASCAQ4FkAGHAQeXAtsBCPIDIAaSBBQKpgQHC60EAgyvBIAEDa8IAg6xCAIADwAWAAAHAQAAAA4AAQEAABECAQEAAAwDBAEAAA0DBAEAAAQFBAEAAAEDBgEAAAMFBgEAAAoHAgEDAAkIAAEAAAgJAgEAAAIJCgEAABIIAgEAABMIAQEAAAcLAgECAAYBAgEAAAUBAAEAABQBDAEAAQQOBAEAAQsNBAEAARACDAEAEwISAhECAwIAAgECAgIAAQsAAQkAAQkAAQYLAAEJAAEBAgYLAAEJAAYJAAEGCQACBgsAAQkACQACBwsAAQkACQABBwsAAQkAAQcJAAILAAEJAAkAAQoJAAEGCgkAAgYKCQAGCQACBgkABgoJAAIJAAYKCQABBwoJAAIJAAcKCQADCwABCQALAAEJAAcKCQACCQAKCQAGT3B0aW9uBmJvcnJvdwpib3Jyb3dfbXV0E2JvcnJvd193aXRoX2RlZmF1bHQIY29udGFpbnMMZGVzdHJveV9ub25lDGRlc3Ryb3lfc29tZRRkZXN0cm95X3dpdGhfZGVmYXVsdAdleHRyYWN0BGZpbGwQZ2V0X3dpdGhfZGVmYXVsdAhpc19lbXB0eQdpc19ub25lB2lzX3NvbWUEbm9uZQZvcHRpb24Jc2luZ2xldG9uBHNvbWUEc3dhcAxzd2FwX29yX2ZpbGwGdG9fdmVjA3ZlYwZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAEAAAAAAADCAEABAAAAAAAAAIBFQoJAAACAAEAAAADQAIAAAAAAAAAADkAAgEBAAAABAsAOAA5AAICAQAAAAQLADcAOAECAwEAAAAFCwA3ADgBIAIEAQAAAAULADcACwE4AgIFAQAAAA0KADgDBAQFCAsAAQcBJwsANwAGAAAAAAAAAABCAgIGAQAADxMLADcADAMKAzgBBAsLAwELAQwCBRELAQELAwYAAAAAAAAAAEICDAILAgIHAQAAEBILADcADAMKAzgBBAsLAwELAQwCBRALAwYAAAAAAAAAAEICFAwCCwICCAEAABEQCwA2AAwCCgIuOAEECAUMCwIBBwAnCwILAUQCAgkBAAAADQoALjgDBAUFCQsAAQcBJwsANgBFAgIKAQAAAA4KAC44AwQFBQkLAAEHAScLADYABgAAAAAAAAAAQwICCwEAABIUCgAuOAMEBQUJCwABBwEnCwA2AAwDCgNFAgwCCwMLAUQCCwICDAEAABMVCwA2AAwECgQuOAEECjgEDAIFDgoERQI4BQwCCwIMAwsECwFEAgsDAg0BAAAUDwsAOgAMAw0DLjgBBAoLAQwCBQ0NA0UCDAILAgIOAQAAFBAOADgDBAQFBgcBJwsAOgAMAg0CRQIMAQsCRgIAAAAAAAAAAAsBAg8BAAAACg4AOAYEBAUGBwAnCwA6AEYCAAAAAAAAAAACEAEAAAADCwA6AAIAAAACAAZzdHJpbmf5B6Ec6wsGAAAACwEACAIIDgMWcgSIAQgFkAF7B4sC+AEIgwQgBqMEFAq3BAYMvQSFAw3CBwIAEwAEABEAGAABBwABAQcAAgAHAQAAABcAAQAABgIBAAAVAQIAABYAAwAABQQFAAAOBAYAAA8EBwAAAggJAAADCgkAAAgLCQAAFAwBAAAHDQcAAAkFBgAACw4GAAAMDwAAAAoQBwABDQIAAAETAAIAAhAJEgEAAhIREgEAAwIVCQEAAw4UBgEAEwESARUTFBMBCgIBCAABCAEBCwIBCAABBggAAQYKAgEBAQMCBwgACAAAAgcIAAoCAwcIAAMIAAMGCAADAwIGCAAGCAACBgoCAwMGCgIDAwIGCgIGCgIBCQABCwIBCQABAgEGCgkAAgcKCQAKCQAIAQMDAwYKAggACAADBQEBAQYKAgMGT3B0aW9uBlN0cmluZwZhcHBlbmQLYXBwZW5kX3V0ZjgFYXNjaWkFYnl0ZXMKZnJvbV9hc2NpaQhpbmRleF9vZgZpbnNlcnQTaW50ZXJuYWxfY2hlY2tfdXRmOBFpbnRlcm5hbF9pbmRleF9vZhlpbnRlcm5hbF9pc19jaGFyX2JvdW5kYXJ5E2ludGVybmFsX3N1Yl9zdHJpbmcKaW50b19ieXRlcwhpc19lbXB0eQZsZW5ndGgEbm9uZQZvcHRpb24Ec29tZQZzdHJpbmcKc3ViX3N0cmluZwh0b19hc2NpaQh0cnlfdXRmOAR1dGY4BnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgBAAAAAAAAAAMIAgAAAAAAAAAAAgEFCgIAAQAACQkOABEMBAQFBgcAJwsAEgACAQEAAAkECwAREBIAAgIBAAAJBAsAEwAREQIDAQAAAwwOABEMBAgLABIAOAAMAQUKOAEMAQsBAgQBAAAJAwsAEAACBQEAAAkECwAQADgCAgYBAAAJBAsAEABBEwIHAQAACQcLAA8ADgEQABQ4AwIIAQAACQULAAsBEQARBwIJAQAAFjgKABAADAcKAQoHQRMlBA0LBwoBEQ0MAwURCwcBCQwDCwMEFAUYCwABBwEnCgAuEQYMCgoACgEMBC4GAAAAAAAAAAALBBEKDAkKAAsBCwoMBgwFLgsFCwYRCgwIDQkLAhEHDQkLCBEHCwkLABUCCgEAABcwCwAQAAwGCgZBEwwHCgILByUEDwoBCgIlDAMFEQkMAwsDBBgKBgoBEQ0MBAUaCQwECwQEIQoGCgIRDQwFBSMJDAULBQQmBSoLBgEHAScLBgsBCwIRDhIAAgsBAAAJBgsAEAALARAAEQ8CDAACAA0AAgAOAAIADwACAAAAAAZ2ZWN0b3KRCKEc6wsGAAAACAEAAgMCZgRoBAVsYQfNAZoBCOcCIAaHAwoMkQPYBAARAAUAAQEAAAkCAwEAAAEEBQEAAAsGAAEAAAIHCAEAAAoJCgEAAAQBAAEAAA8LAAEAAA4KAQEAAA0JAAEAAAAMAAEAAAgCDQEAAAMODQEAAAYODwEAAAwHCgEAAAcQAAEAABAHCgEACQoLCgABCgkAAQYKCQABAwIGCgkAAwEGCQACBwoJAAkAAgcKCQADAQcJAAEHCgkAAQkAAwcKCQADAwIHCgkACgkAAQECBgoJAAYJAAIBAwMHCgkACQADAwMDAwIDAwMDBwoJAAMGYXBwZW5kBmJvcnJvdwpib3Jyb3dfbXV0CGNvbnRhaW5zDWRlc3Ryb3lfZW1wdHkFZW1wdHkIaW5kZXhfb2YGaW5zZXJ0CGlzX2VtcHR5Bmxlbmd0aAhwb3BfYmFjawlwdXNoX2JhY2sGcmVtb3ZlB3JldmVyc2UJc2luZ2xldG9uBHN3YXALc3dhcF9yZW1vdmUGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAgAAAAAAAAECAAEBAgACAQIAAwECAAQBAgAFAQIABgECAAcBAgAIAQAAAQdACgAAAAAAAAAADAENAQsARAoLAQIJAQAAESYKAC5BCgwDCgMGAAAAAAAAAAAhBAsLAAECBgAAAAAAAAAADAILAwYBAAAAAAAAABcMAQoCCgEjBCMFFgoACgIKAUcKCwIGAQAAAAAAAAAWDAILAQYBAAAAAAAAABcMAQURCwABAgoBAAAAEQ0BOAAOATgBIAQMBQcKAA0BRQpECgUCCwABCwFGCgAAAAAAAAAAAgsBAAAABQsAQQoGAAAAAAAAAAAhAgwBAAASIQYAAAAAAAAAAAwCCgBBCgwDCgIKAyMEGwUKCgAKAkIKCgEhBBYLAAELAQEIAgsCBgEAAAAAAAAAFgwCBQULAAELAQEJAg0BAAASIwYAAAAAAAAAAAwCCgBBCgwDCgIKAyMEHAUKCgAKAkIKCgEhBBcLAAELAQEICwICCwIGAQAAAAAAAAAWDAIFBQsAAQsBAQkGAAAAAAAAAAACDgEAABMlCgAuQQoMBAoBCgQmBAwLAAEHACcLBAYBAAAAAAAAABcMBAoBCgQjBCIFFQoADAMKAQwCCwEGAQAAAAAAAAAWDAELAwsCCgFHCgUQCwBFCgIPAQAAAyAKAC5BCgwDCgIKAyQEDAsAAQcAJwoACwFECgoCCgMjBB0FFAoACgIKA0cKCwIGAQAAAAAAAAAWDAIFDwsAAQIQAQAAAxcKAC44ASAEBgUKCwABBwAnCgAuQQoGAQAAAAAAAAAXDAIKAAsBCwJHCgsARQoCAAdhZGRyZXNzZaEc6wsGAAAABgEAAgMCBQUHAwcKDwgZIAw5EAAAAAEAAQAAAQMHYWRkcmVzcwZsZW5ndGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQABAAAAAgYgAAAAAAAAAAIACXR5cGVfbmFtZYwEoRzrCwYAAAAKAQAGAgYIAw4pBTcsB2N5CNwBIAb8AQcKgwIGDIkC0wEN3AMCAA0AAgAEAAEHAAIABwAABgABAQAABQIDAAAHAgQAAAgCBAAACQEEAAEKAAYAAgMDBwACDAkEAAABCAABBggAAQYIAQEIAQQKAgMDBgoCAQMBBgoCAQIBCgIFAgYCAwoCBgoCBlN0cmluZwhUeXBlTmFtZQdhZGRyZXNzCGFzX2J5dGVzBWFzY2lpDWJvcnJvd19zdHJpbmcDZ2V0C2dldF9hZGRyZXNzCmdldF9tb2R1bGULaW50b19zdHJpbmcGbGVuZ3RoBG5hbWUGc3RyaW5nCXR5cGVfbmFtZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAgE6CgIBAAACAQsIAQABAgABAQAAAAMLABAAAgIBAAAFIREFBgIAAAAAAAAAGAwDCwAQABEGDAQHAQwBBgAAAAAAAAAADAIKAgoDIwQcBRENAQoECgJCCBRECAsCBgEAAAAAAAAAFgwCBQwLBAELAREHAgMBAAAKJxEFBgIAAAAAAAAAGAYCAAAAAAAAABYMAwsAEAARBgwFBwEMBAoFCgNCCAwCBwAMAQoCDgEiBCAFFw0ECwIURAgLAwYBAAAAAAAAABYMAwUMCwUBCwIBCwQRBwIEAQAAAAQOABAAFAIAAAAKYml0X3ZlY3RvcqsGoRzrCwYAAAAKAQACAgIEAwYjBSkkB01tCLoBIAbaASgKggIIDIoC7wMN+QUEAAIAAAcAAAYAAQAABwIDAAAJAgMAAAgCAwAAAwQFAAAEBgAAAAUEAAABAwEIAAIHCAADAAIGCAADAQEBBggAAgoBAwEHAQUDBwEDAwMJQml0VmVjdG9yCWJpdF9maWVsZApiaXRfdmVjdG9yDGlzX2luZGV4X3NldAZsZW5ndGggbG9uZ2VzdF9zZXRfc2VxdWVuY2Vfc3RhcnRpbmdfYXQDbmV3A3NldApzaGlmdF9sZWZ0BXVuc2V0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAgAAAAAAAwgBAAIAAAAAAAMIAQAAAAAAAAADCAAEAAAAAAAAAAICBAMBCgEAAQAAByUKAAYAAAAAAAAAACQEBQUHBwEnCgAHAyMEDAUOBwEnBgAAAAAAAAAADAJABQAAAAAAAAAADAEoCgIKACMEIAUYDQEJRAULAgYBAAAAAAAAABYMAgUSKAsACwESAAIBAQAACBQKAQoAEABBBSMEBwULCwABBwAnCwAPAAsBQwUMAggLAhUCAgEAAAgUCgEKABAAQQUjBAcFCwsAAQcAJwsADwALAUMFDAIJCwIVAgMBAAAJWQoBCgAQARQmBCEKABAAQQUMBgYAAAAAAAAAAAwECgQKBiMEHgURCgAPAAoEQwUMAwkLAxULBAYBAAAAAAAAABYMBAUMCwABBVgKAQwFCgUKABABFCMEQQUqCgAKBQwCLgsCEQQENwoACgUKARcRAQU8CgAKBQoBFxECCwUGAQAAAAAAAAAWDAUFIwoAEAEUCwEXDAUKBQoAEAEUIwRWBU4KAAoFEQILBQYBAAAAAAAAABYMBQVHCwABAgQBAAADEQoBCgAQAEEFIwQHBQsLAAEHACcLABAACwFCBRQCBQEAAAMECwAQAEEFAgYBAAAAJQoBCgAQARQjBAcFCwsAAQcAJwoBDAIKAgoAEAEUIwQhBRQKAAoCEQQgBBwLAAEFIQsCBgEAAAAAAAAAFgwCBQ0LAgsBFwIAAQAAAA1maXhlZF9wb2ludDMy1gShHOsLBgAAAAoBAAICAgQDBh4FJBYHOnoItAEgBtQBRAqYAgUMnQKJAg2mBAIABAAABwAABwABAAADAAEAAAECAwAAAgEDAAAFAwEAAAYDBAACAwgAAQMCAwMBCAABAQEEBAEEBAQADEZpeGVkUG9pbnQzMhRjcmVhdGVfZnJvbV9yYXRpb25hbBVjcmVhdGVfZnJvbV9yYXdfdmFsdWUKZGl2aWRlX3U2NA1maXhlZF9wb2ludDMyDWdldF9yYXdfdmFsdWUHaXNfemVybwxtdWx0aXBseV91NjQFdmFsdWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQQQ//////////8AAAAAAAAAAAMIAQABAAAAAAADCAIAAgAAAAAAAwgDAAIAAAAAAAMIBAABAAAAAAADCAUAAgAAAAAAAAIBCAMAAQAABRQLADUOARAAFDUYMSAwDAIKAgcAJQQPBREHAycLAjQCAQEAAAUdDgEQABQGAAAAAAAAAAAiBAcFCQcEJwsANTEgLw4BEAAUNRoMAgoCBwAlBBgFGgcCJwsCNAICAQAABjAKADUxQC8MBQsBNTEgLwwECgQyAAAAAAAAAAAAAAAAAAAAACIEDwURBwEnCwULBBoMAwoDMgAAAAAAAAAAAAAAAAAAAAAiBBwIDAIFIAsABgAAAAAAAAAAIQwCCwIEIwUlBwUnCgMHACUEKgUsBwUnCwM0EgACAwEAAAcDCwASAAIEAQAABwQOABAAFAIFAQAABwYOABAAFAYAAAAAAAAAACECAAAABw1maXhlZF9wb2ludDMyDEZpeGVkUG9pbnQzMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBm9wdGlvbgZPcHRpb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQVhc2NpaQZTdHJpbmcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQVhc2NpaQRDaGFyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEKYml0X3ZlY3RvcglCaXRWZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQZzdHJpbmcGU3RyaW5nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEJdHlwZV9uYW1lCFR5cGVOYW1lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAyA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQAAAAAAAAApA2JhZ+wFoRzrCwYAAAALAQAIAggMAxRwBIQBDAWQAVIH4gG5AQibAyAGuwMKCsUDCAzNA+YBDbMFBAAEAAsAEgAVAAAMAAICBAADAQIAABEAAQAAAwIDAgcEAAUEBQIHBAAGBgcCBwQAEwYIAgcEAAcECQEHAAgECQIHBAAQCgsAAA8KCQAACgEDAAEDDgMCBwQBBQ8FAgcEAQYQBwIHBAEMDwkBBwENDwkCBwQBExAIAgcEAgkMAwACEQAMAAoNCw0MDQ8NDREODQEHCAIBCAADBwgACQAJAQACBggACQABBgkBAgcIAAkAAQcJAQEJAQEBAQYIAAEDAQgBAgkACQEDBwgBCQAJAQIGCAEJAAIHCAEJAAEJAAIIAQMDQmFnCVR4Q29udGV4dANVSUQDYWRkA2JhZwZib3Jyb3cKYm9ycm93X211dAhjb250YWlucxJjb250YWluc193aXRoX3R5cGUGZGVsZXRlDWRlc3Ryb3lfZW1wdHkNZHluYW1pY19maWVsZAdleGlzdHNfEGV4aXN0c193aXRoX3R5cGUCaWQIaXNfZW1wdHkGbGVuZ3RoA25ldwZvYmplY3QGcmVtb3ZlBHNpemUKdHhfY29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAACAg4IARQDAAEAAAMFCwAREQYAAAAAAAAAABIAAgEBAAADDgoADwALAQsCOAAKABABFAYBAAAAAAAAABYLAA8BFQICAQAAAwULABAACwE4AQIDAQAAAwULAA8ACwE4AgIEAQAACA8KAA8ACwE4AwwCCgAQARQGAQAAAAAAAAAXCwAPARULAgIFAQAAAwULABAACwE4BAIGAQAAAwULABAACwE4BQIHAQAAAwQLABABFAIIAQAAAwYLABABFAYAAAAAAAAAACECCQEAABIOCwATAAwCDAELAgYAAAAAAAAAACEECQULBwAnCwEREAIAAAABAANiY3OVD6Ec6wsGAAAACwEACgIKCgMUhwEEmwEYBbMBgwEHtgLeAgiUBUAG1AU3CosGBgyRBssIDdwOAgADAQMBCgEfAAIAAAcAAgEHAQAAAB4AAQEAAAgBAgAABgIBAAALAwQAAAwDBQAAFAMGAAATAwcAABIDCAAAFwMHAAAVAwkAABYDCgAAGgMBAAAbAwsAABkDDAAAGAMNAAANAw4AAA4DDwAAEQMQAAAQAxEAAA8DEgABHgABAQACCRMhAQACHRQhAQADHBUTAQAEBQEEAAQHEwcAFBQXBhYEFQQWBRUFFgYVBhYHFQcWCBUIAQYJAAEKAgEIAAEHCAABBQEBAQIBAwEEAQoFAQoBAQoKAgEKAwEKBAELAQEFAQsBAQEBCwEBAgELAQEDAQsBAQQAAQkAAQcKCQACCgIDAgECAwMCAwMEAgQEAwMCAwMDAwoFAwMDCgEDAwMKAgMDAwoKAgMDAwoDAwMDCgQBCwEBCQADQkNTBk9wdGlvbgdhZGRyZXNzA2JjcwVieXRlcwpmcm9tX2J5dGVzFGludG9fcmVtYWluZGVyX2J5dGVzBmxlbmd0aANuZXcEbm9uZQZvcHRpb24McGVlbF9hZGRyZXNzCXBlZWxfYm9vbBNwZWVsX29wdGlvbl9hZGRyZXNzEHBlZWxfb3B0aW9uX2Jvb2wQcGVlbF9vcHRpb25fdTEyOA9wZWVsX29wdGlvbl91NjQOcGVlbF9vcHRpb25fdTgJcGVlbF91MTI4CHBlZWxfdTY0B3BlZWxfdTgQcGVlbF92ZWNfYWRkcmVzcw1wZWVsX3ZlY19ib29sD3BlZWxfdmVjX2xlbmd0aA1wZWVsX3ZlY191MTI4DHBlZWxfdmVjX3U2NAtwZWVsX3ZlY191OA9wZWVsX3ZlY192ZWNfdTgHcmV2ZXJzZQRzb21lCHRvX2J5dGVzBnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAAKBQEACgEBAAoCAQAKCgIBAAoDAQAKBAEAAAIBBAoCAAEAABMDCwA4AAIBAQAAEwUNADgBCwASAAICAQAAAQcLABMADAENATgBCwECAwEAABYjCgAQAEEGERkmBAcFCwsAAQcAJ0AGAAAAAAAAAAAGAAAAAAAAAAAMAgwBCgIRGSMEHgUUDQEKAA8ARQZEBgsCBgEAAAAAAAAAFgwCBQ8LAAELAREYAgQBAAAXFQsAEQUMAgoCMQAhBAoJDAEFEwsCMQEhBA8FEQcBJwgMAQsBAgUBAAATDwoAEABBBgYBAAAAAAAAACYEBwULCwABBwAnCwAPAEUGAgYBAAAYKAoAEABBBgYIAAAAAAAAACYEBwULCwABBwAnBgAAAAAAAAAAMQAMAgwDCgIxQCMEJAUUCgAPAEUGNAwBCwMLAQoCLxYMAwsCMQgWDAIFDwsAAQsDAgcBAAAZKAoAEABBBgYQAAAAAAAAACYEBwULCwABBwAnMgAAAAAAAAAAAAAAAAAAAAAxAAwCDAMKAjGAIwQkBRQKAA8ARQY1DAELAwsBCgIvFgwDCwIxCBYMAgUPCwABCwMCCAEAABowBgAAAAAAAAAAMQAGAAAAAAAAAAAMAgwDDAQKAgYEAAAAAAAAACUECwUPCwABBwInCgAPAEUGNAwBCwIGAQAAAAAAAAAWDAILBAoBBn8AAAAAAAAAHAoDLxsMBAsBBoAAAAAAAAAAHAYAAAAAAAAAACEEJwUsCwMxBxYMAwUGCwABCwQCCQEAABsZCgARCAYAAAAAAAAAAAcDDAMMAQwCCgEKAiMEFQUMDQMKABEDRAQLAQYBAAAAAAAAABYMAQUHCwABCwMCCgEAABwZCgARCAYAAAAAAAAAAAcEDAMMAQwCCgEKAiMEFQUMDQMKABEERAULAQYBAAAAAAAAABYMAQUHCwABCwMCCwEAAB0ZCgARCAYAAAAAAAAAAAcFDAMMAQwCCgEKAiMEFQUMDQMKABEFRAYLAQYBAAAAAAAAABYMAQUHCwABCwMCDAEAAB4ZCgARCAYAAAAAAAAAAAcGDAMMAQwCCgEKAiMEFQUMDQMKABELRAELAQYBAAAAAAAAABYMAQUHCwABCwMCDQEAAB8ZCgARCAYAAAAAAAAAAAcHDAMMAQwCCgEKAiMEFQUMDQMKABEGRAcLAQYBAAAAAAAAABYMAQUHCwABCwMCDgEAACAZCgARCAYAAAAAAAAAAAcIDAMMAQwCCgEKAiMEFQUMDQMKABEHRAgLAQYBAAAAAAAAABYMAQUHCwABCwMCDwEAAA4OCgARBAQICwARAzgCDAEFDAsAATgDDAELAQIQAQAADw4KABEEBAgLABEEOAQMAQUMCwABOAUMAQsBAhEBAAAQDgoAEQQECAsAEQU4BgwBBQwLAAE4BwwBCwECEgEAABEOCgARBAQICwARBjgIDAEFDAsAATgJDAELAQITAQAAEg4KABEEBAgLABEHOAoMAQUMCwABOAsMAQsBAgAAAANoZXizCqEc6wsGAAAACAEABAMEFQQZAgUbJQdALAhsQAasAZ8GDMsHwgIABAEFAAMAAAAAAQAAAAACAQEAAQADBAEAAwEBCgIBAgUKCgIHCgIDAwoCAgcKCQAKCQAABAIDAwoCBQEBAQICBmFwcGVuZAZkZWNvZGULZGVjb2RlX2J5dGUGZW5jb2RlA2hleAZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAAKCgKCBoACAjAwAjAxAjAyAjAzAjA0AjA1AjA2AjA3AjA4AjA5AjBhAjBiAjBjAjBkAjBlAjBmAjEwAjExAjEyAjEzAjE0AjE1AjE2AjE3AjE4AjE5AjFhAjFiAjFjAjFkAjFlAjFmAjIwAjIxAjIyAjIzAjI0AjI1AjI2AjI3AjI4AjI5AjJhAjJiAjJjAjJkAjJlAjJmAjMwAjMxAjMyAjMzAjM0AjM1AjM2AjM3AjM4AjM5AjNhAjNiAjNjAjNkAjNlAjNmAjQwAjQxAjQyAjQzAjQ0AjQ1AjQ2AjQ3AjQ4AjQ5AjRhAjRiAjRjAjRkAjRlAjRmAjUwAjUxAjUyAjUzAjU0AjU1AjU2AjU3AjU4AjU5AjVhAjViAjVjAjVkAjVlAjVmAjYwAjYxAjYyAjYzAjY0AjY1AjY2AjY3AjY4AjY5AjZhAjZiAjZjAjZkAjZlAjZmAjcwAjcxAjcyAjczAjc0Ajc1Ajc2Ajc3Ajc4Ajc5AjdhAjdiAjdjAjdkAjdlAjdmAjgwAjgxAjgyAjgzAjg0Ajg1Ajg2Ajg3Ajg4Ajg5AjhhAjhiAjhjAjhkAjhlAjhmAjkwAjkxAjkyAjkzAjk0Ajk1Ajk2Ajk3Ajk4Ajk5AjlhAjliAjljAjlkAjllAjlmAmEwAmExAmEyAmEzAmE0AmE1AmE2AmE3AmE4AmE5AmFhAmFiAmFjAmFkAmFlAmFmAmIwAmIxAmIyAmIzAmI0AmI1AmI2AmI3AmI4AmI5AmJhAmJiAmJjAmJkAmJlAmJmAmMwAmMxAmMyAmMzAmM0AmM1AmM2AmM3AmM4AmM5AmNhAmNiAmNjAmNkAmNlAmNmAmQwAmQxAmQyAmQzAmQ0AmQ1AmQ2AmQ3AmQ4AmQ5AmRhAmRiAmRjAmRkAmRlAmRmAmUwAmUxAmUyAmUzAmU0AmU1AmU2AmU3AmU4AmU5AmVhAmViAmVjAmVkAmVlAmVmAmYwAmYxAmYyAmYzAmY0AmY1AmY2AmY3AmY4AmY5AmZhAmZiAmZjAmZkAmZlAmZmCgIBAAABAAACIQYAAAAAAAAAAAcDDgBBAQwEDAUMAwoDCgQjBB8FDA0FDAIHAgwBCwIOAQ4ACgNCARQ0QgAUOAALAwYBAAAAAAAAABYMAwUHCwUCAQEAAAUvBgAAAAAAAAAABwMOAEEBDAMMBAwCCgMGAgAAAAAAAAAZBgAAAAAAAAAAIQQOBRAHACcKAgoDIwQtBRUOAAoCQgEUEQIxEBgOAAoCBgEAAAAAAAAAFkIBFBECFgwBDQQLAUQBCwIGAgAAAAAAAAAWDAIFEAsEAgIAAAAGQDEwCgAlBAkKADE6IwwBBQsJDAELAQQSCwAxMBcMBQU+MUEKACUEGwoAMUcjDAIFHQkMAgsCBCYxCgsAFjFBFwwEBTwxYQoAJQQvCgAxZyMMAwUxCQwDCwMENAU2BwEnMQoLABYxYRcMBAsEDAULBQIAA3BhecMGoRzrCwYAAAAJAQAIAggKAxJNBF8OBW1+B+sBrQEImAMgBrgDCgzCA9YCAAkAAgAPABABAAwBAAEDAQIAAAgAAQEAAAwCAQEAAA4DAQEAAA0EAQEAAAMCAQEAAAUFAQEAAAYGAQEAAAcHAQEAAQQCEAEAAQUFAQEAAQwCCgEAAgoLAQEMAwsICQALCgoMAAwBDAgMCQwGDAILAAEJAAYIAQADBwsAAQkAAwcIAQMHCwABCQAKAwcIAQQHCwABCQADBQcIAQIHCwABCQALAAEJAAIHCwABCQAKCwABCQACCgsAAQkABQEGCAEBBQELAAEJAAIJAAUBCQACAwMBAwMDAwoLAAEJAAEKCwABCQADCwABCQADAwRDb2luCVR4Q29udGV4dARjb2luD2RpdmlkZV9hbmRfa2VlcA1kaXZpZGVfaW50b19uBGpvaW4Iam9pbl92ZWMVam9pbl92ZWNfYW5kX3RyYW5zZmVyBGtlZXADcGF5D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIFc3BsaXQSc3BsaXRfYW5kX3RyYW5zZmVyCXNwbGl0X3ZlYwh0cmFuc2Zlcgp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAAEAAAEFCwALAREMOAACAQEEAAEICwALAQoCOAELAi44AgICAQQADRsGAAAAAAAAAAAOAUEODAQMAwoDCgQjBBYFCgoADgEKA0IOFAoCOAMLAwYBAAAAAAAAABYMAwUFCwABCwIBAgMBBAABBwsACwELAzgBCwI4AAIEAQQADx8LAAsBCgI4BAwFBgAAAAAAAAAADgVBCgwEDAMKAwoEIwQaBQ8NBUUKCgIuEQw4AAsDBgEAAAAAAAAAFgwDBQoLAgELBUYKAAAAAAAAAAACBQEEAAEECwALATgFAgYBBAARGgYAAAAAAAAAAA4BQQoMBAwDCgMKBCMEFQUKDQFFCgwCCgALAjgFCwMGAQAAAAAAAAAWDAMFBQsAAQsBRgoAAAAAAAAAAAIHAQQAChIOAEEKBgAAAAAAAAAAJAQGBQgHACcNAEUKDAINAgsAOAYLAgsBOAACAANzdWnYBqEc6wsGAAAACgEADgIOMAM+PgR8DgWKAYUBB48CgQIIkARABtAEZgq2BQUMuwVtABYBEgAJAAoAFwAZABoABAIAAQMHAQAAAgAEAQABAgUEAQABAwEMAQABAwIMAQABAwYMAQABBQcCAAYIBwAAEAABAAAXAgMAAREDCQEAAgwQBwEAAg8REgEAAwsLDAECAxgPEAEABBMOAwEMBBQUAwEMBQ4FBwAFFQUGAAIIBQoHDQYKBAoDCggTAQcIBwELAgEIAAILBAEIAAUABAsFAQgACwMBCAALAgEIAAsGAQgAAQYIBwEFAQMBCAgBCwEBCQABCAAHCQACCgIKAgoCCwEBCAgHCAcCCwYBCQALBQEJAAELBQEIAAEJAAELBgEJAAELAwEJAAIHCwMBCQADAQsCAQkAAQsEAQgAAgkABQdCYWxhbmNlBENvaW4MQ29pbk1ldGFkYXRhBk9wdGlvbgNTVUkGU3VwcGx5C1RyZWFzdXJ5Q2FwCVR4Q29udGV4dANVcmwHYmFsYW5jZQRjb2luD2NyZWF0ZV9jdXJyZW5jeQ5kZXN0cm95X3N1cHBseQtkdW1teV9maWVsZAVlcG9jaA9pbmNyZWFzZV9zdXBwbHkDbmV3BG5vbmUGb3B0aW9uFHB1YmxpY19mcmVlemVfb2JqZWN0D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIDc3VpCHRyYW5zZmVyFHRyZWFzdXJ5X2ludG9fc3VwcGx5CnR4X2NvbnRleHQDdXJsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgAypo7AAAAAAMIAOQLVAIAAAADCAAA6IkEI8eKBSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCBANTVUkKAgQDU3VpCgIBAAACAQ0BAAAAAAQvCgAuEQoHBSEEBwULCwABBwEnCgAuEQkGAAAAAAAAAAAhBBIFFgsAAQcAJwkSADEJBwYHBwcIOAALADgBDAEMBAsBOAILBDgDDAINAgcEOAQMAwsCOAUBCwMCAQEEAAMECwALATgGAgADdXJsqgKhHOsLBgAAAAkBAAQCBAgDDBkFJRQHOU4IhwFACscBBgzNATIN/wECAAgBAgABBwABAAcAAAQAAQAABQIBAAADAwAAAAcEBQABBgIAAAEIAQEIAAEKAgEGCAACBwgACAEABlN0cmluZwNVcmwFYXNjaWkJaW5uZXJfdXJsCm5ld191bnNhZmUVbmV3X3Vuc2FmZV9mcm9tX2J5dGVzBnN0cmluZwZ1cGRhdGUDdXJsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQACAQgIAQABAAAFAwsAEgACAQEAAAUECwARBBIAAgIBAAAFBAsAEAAUAgMBAAAFBQsBCwAPABUCAAAABGNvaW6BEqEc6wsGAAAADQEAFgIWPgNUmwIE7wIkBZMD4wIH9gWiBQiYC0AG2AseCvYLNAuqDAgMsgz0BA2mEQ4OtBEOAA8BCwEtATIADAAZACwAOQA7ADwAQQABDAEAAQACDAEAAQAHDAEAAQADAwEAAQEFBwACBAcBAAADBQcABAAEAQABBAYEAQABBgkEAAgIAgAKCgcAADgAAQEAADoCAwEAADMEBQEAADQEBgEAAEMHAQEAAAwHCAEAAA0JCgEAABoLDAEAACMMDQEAADcODAEAAC8PEAEAACUREAEAADESDAEAABcSEwEAAEQUDAEAABYMEAEAABAVFgECACYXDAEAACgYDQEAAA4ZAQEAACcaEAEAAD8bEAEAAEAcEAEAAD0bEAEAAD4cEAEAABsdHgEAAB4dHwEAAB8dIAEAABwdHwEAAB0dIQEAATIqIAACMCIvAQADQiofAAQRIgMBAgQTLAEBAAQWDRABAAQiKw0BAAQlJQEBAAQxJA0BAAQ1BQEBAARDCAEBAAREEA0BAAUYIhABAwYUIxAABioUIwAHLi0QAQwJJCcoAQIKKyAuACciKCImIggiJSIJIgQiDCIpIiMiLiIqKSEiJCIiIhEiLQwfLgEGCwIBCQABAwELAgEJAAELCAEJAAEHCwIBCQABBgsIAQkAAQcLCAEJAAEGCwABCQABBgsHAQkAAQcLAAEJAAEHCwcBCQACCwcBCQAHCAoBCwABCQABCwcBCQADBwsHAQkAAwcICgIHCwcBCQALAAEJAAACBwsAAQkACwABCQADBwsAAQkAAwcICgEKCwABCQABBwgKBwkAAgoCCgIKAgsFAQgLBwgKAgsCAQkACwEBCQADBwsCAQkAAwcICgIHCwIBCQADAgcLAgEJAAsAAQkABAcLAgEJAAMFBwgKAwYLAgEJAAcLAQEJAAgGAwYLAgEJAAcLAQEJAAgEAQYLAQEJAAECAQgGAQgEAQsFAQgLAQkAAQgJAgcLBwEJAAMCBwsHAQkACwcBCQADAwMKCwABCQABBgkAAQEBCwMBCQABCgICBwsIAQkAAwIHCwgBCQALBwEJAAIJAAUBCAsBCwUBCQAHQmFsYW5jZQRDb2luDENvaW5NZXRhZGF0YQ9DdXJyZW5jeUNyZWF0ZWQGT3B0aW9uBlN0cmluZwZTdXBwbHkLVHJlYXN1cnlDYXAJVHhDb250ZXh0A1VJRANVcmwFYXNjaWkHYmFsYW5jZQtiYWxhbmNlX211dARidXJuBGNvaW4PY3JlYXRlX2N1cnJlbmN5DWNyZWF0ZV9zdXBwbHkIZGVjaW1hbHMPZGVjcmVhc2Vfc3VwcGx5BmRlbGV0ZQtkZXNjcmlwdGlvbgxkZXN0cm95X3plcm8NZGl2aWRlX2ludG9fbgRlbWl0BWV2ZW50DGZyb21fYmFsYW5jZQxnZXRfZGVjaW1hbHMPZ2V0X2Rlc2NyaXB0aW9uDGdldF9pY29uX3VybAhnZXRfbmFtZQpnZXRfc3ltYm9sCGljb25fdXJsAmlkD2luY3JlYXNlX3N1cHBseQxpbnRvX2JhbGFuY2UTaXNfb25lX3RpbWVfd2l0bmVzcwRqb2luBG1pbnQRbWludF9hbmRfdHJhbnNmZXIMbWludF9iYWxhbmNlBG5hbWUDbmV3Cm5ld191bnNhZmUGb2JqZWN0Bm9wdGlvbg9wdWJsaWNfdHJhbnNmZXIDcHV0BHNvbWUFc3BsaXQGc3RyaW5nBnN1cHBseQpzdXBwbHlfbXV0DHN1cHBseV92YWx1ZQZzeW1ib2wEdGFrZQx0b3RhbF9zdXBwbHkIdHJhbnNmZXIUdHJlYXN1cnlfaW50b19zdXBwbHkKdHhfY29udGV4dAV0eXBlcxJ1cGRhdGVfZGVzY3JpcHRpb24PdXBkYXRlX2ljb25fdXJsC3VwZGF0ZV9uYW1lDXVwZGF0ZV9zeW1ib2wDdXJsBHV0ZjgFdmFsdWUEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAAAAgIhCAkMCwcBCQABAgYhCAkSAikIBjYIBBUIBiALBQEICwICAiEICTgLCAEJAAMCARICAiIAIgMiASIAAQAAEAQLADcAOAACAQEAAAMGCwA6AAwBESsLAQICAQAAEAMLADcAAgMBAAAQAwsANgACBAEAABAECwA3ATgBAgUBAAAQAwsANwECBgEAABADCwA2AQIHAQAAEAULAREsCwA5AQIIAQAADQYLADoBDAERKwsBAgkBAAAQBwsCESwLAAsBOAI5AQIKAQAAEAYLAAsBOAM4BAECCwEEAA0KCwE6AQwCESsLADYBCwI4BAECDAEAABAGCwA2AQsBCwI4BQINAQAAJjsKAQYAAAAAAAAAACQEBQULCwABCwIBBwEnCgEKAC44BiUEEgUYCwABCwIBBwInQAwAAAAAAAAAAAwFBgAAAAAAAAAADAMKAC44BgoBGgwEKAoDCgEGAQAAAAAAAAAXIwQ1BSoNBQoACgQKAjgHRAwLAwYBAAAAAAAAABYMAwUiCwABCwIBCwUCDgEAABAFCwARLDgIOQECDwEAAA0HCwA6AQwBESsLATgJAhABAAAQHA4AOAoEBAUICwYBBwAnCgE5AjgLCgYRLAsAOAw5AAsGESwLAQsDESALAhEeCwQRIAsFOQMCEQEAABAICwIRLAsANgALATgNOQECEgEAABAFCwA2AAsBOA0CEwEEAA0JCwE6AQwCESsLADYACwI4DgIUAQQAEAcLAAsBCwM4DwsCOBACFQEEABAFCwILATYCFQIWAQQAEAULAgsBNgMVAhcBBAAQBQsCCwE2BBUCGAEEABAHCwIRLzgRCwE2BRUCGQEAABAECwA3BhQCGgEAABAECwA3AhQCGwEAABAECwA3AxQCHAEAABAECwA3BBQCHQEAABAECwA3BRQCAgEAAQECAQMBBAEFAQEAIgEiAiIDIgQiBSIGIgAEaGFzaHGhHOsLBgAAAAYBAAIDAgoFDAcHExoILSAMTQgAAQAAAAEAAAIAAQABBgoCAQoCCmJsYWtlMmIyNTYEaGFzaAlrZWNjYWsyNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgABAgABAQIAAARobWFjZKEc6wsGAAAABgEAAgMCBQUHCgcREwgkIAxEBAAAAAEAAQACBgoCBgoCAQoCBGhtYWMNaG1hY19zaGEzXzI1NgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAAEbWF0aKcFoRzrCwYAAAAGAQACAwIjBSUSBzc5CHAgDJAB+QMAAgADAAEAAAQAAQAAAAABAAAFAgEAAAYBAQAABwMDAAABAAEAAgMDAQMCAwIBBAMEBAQDDw8PBGRpZmYTZGl2aWRlX2FuZF9yb3VuZF91cARtYXRoA21heANtaW4DcG93BHNxcnQJc3FydF91MTI4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQAAAQsKAAoBJAQHCwAMAgUJCwEMAgsCAgEBAAABCwoACgEjBAcLAAwCBQkLAQwCCwICAgEAAAEPCgAKASQECQsACwEXDAIFDQsBCwAXDAILAgIDAQAAASEGAQAAAAAAAAAMAgoBMQEmBB8FBwoBMQIZMQAhBBYKAAsAGAwACwExAhoMAQUeCwIKABgMAgsBMQEXDAEFAgsCAgQBAAAEKzIAAAAAAAAAAAEAAAAAAAAADAEyAAAAAAAAAAAAAAAAAAAAAAwCCwA1DAMKATIAAAAAAAAAAAAAAAAAAAAAIgQoBQwKAwoCCgEWJgQfCwMKAgoBFhcMAwsCMQEwCgEWDAIFIwsCMQEwDAILATECMAwBBQcLAjQCBQEAAAUrSgAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAADAFKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAgsATQwDCgFKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiBCgFDAoDCgIKARYmBB8LAwoCCgEWFwwDCwIxATAKARYMAgUjCwIxATAMAgsBMQIwDAEFBwsCNQIGAQAAARMKAAoBGQYAAAAAAAAAACEECwsACwEaDAIFEQsACwEaBgEAAAAAAAAAFgwCCwICAAVjbG9ja6IDoRzrCwYAAAALAQAIAggMAxQfBDMCBTUeB1N6CM0BIAbtASwKmQIIDKECTw3wAgIAAwAHAAsADAAACAABAgQAAwECAAAKAAEAAAUCAwAABAQDAAEDAwYAAgkIAwEIAwgCBQAEBwEGCAABAwEGCAIAAwcIAAMGCAIBBQEIAQEIAAEJAAVDbG9jawlUeENvbnRleHQDVUlEBWNsb2NrGWNvbnNlbnN1c19jb21taXRfcHJvbG9ndWUGY3JlYXRlAmlkBm9iamVjdAZzZW5kZXIMc2hhcmVfb2JqZWN0DHRpbWVzdGFtcF9tcwh0cmFuc2Zlcgp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgYIAQoDAAEAAAMECwAQABQCAQAAAAMNCwARBQcBIQQGBQgHACcRAwYAAAAAAAAAABIAOAACAgAAAAMPCwIRBQcBIQQGBQoLAAEHACcLAQsADwAVAgABAAVlY3ZyZooBoRzrCwYAAAAHAQACAwIFBQcPBxYTCCkgBkkeDGcEAAAAAQABAAQGCgIGCgIGCgIGCgIBAQVlY3ZyZgxlY3ZyZl92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAABAgAABWV2ZW50V6Ec6wsGAAAABgEAAgMCBgUIBAcMCwgXIAw3BAABAAAAAQEDAQkAAARlbWl0BWV2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQIAAAVraW9za8odoRzrCwYAAAANAQAWAhZSA2jOAgS2AzgF7gPsAwfaB/MGCM0OQAaND3gKhRBRC9YQBAzaEJkMDfMcEg6FHQYALgE3ABMAGAAbABwAHgA2AEwATgBPAAYMAAAHDAAACwwBDAEAAQAAAAQHAAAIBwAACQcAAAUDAQwBAQoHAQAAAgAEAQABAwIMAQABBwMHAAcQBAAIDAIACQ0MAQABCQ4AAQABCg8CAAA0AAEAABcCAwAASgQFAABLBgUAADkHBQEMADIIBQEMAE0JCgEMADALBQEMADoMBQEMAD8NDgEMADEPEAEMAEMRDgEMAEYSBQEMAFQTAwAAIxQVAAApFBUAACcUFQAAKBQVAAAiFhUAAFEWFwAASRgFAABQGRcAADgaGwAAKxocAAA9Gh0AAD4WHgAAFB8gAQwAFQkhAQwAFgkiAQwARyMFAQwAQSQlAQwAQCQlAQwAQiQdAQwBGkMKAQABKkIVAQACLTsdAQACU0QdAQACVQUpAQADIS4vAQADJS8pAQADTUUvAQADUzodAQAEETEFAgcEBB9HFQEHBEQ1NwIHBARFNTYCBwQFETEFAgcMBRRHSgIHDAUVNUwCBwwFH0cVAQcFRDU3AgcMBh0KBQEDBxknBQAHJCAlAQgHNAAnAAdSLSUACTU8PQEACkgqGwAlKDUrJig1Ci4wKjIECi00MjAqNDM4BwosNCkoJygjKC0yOAoJCiIdIR0kKCgoMUYrSCtJLzAwMAEHCBACCAAIAQMIAAgBBwgQAQsKAQgNAwcIAAYIAQYIEAADBwgABggBBQMHCAAGCAEJAAQHCAAGCAEGCw4BCQAJAAMHCAAGCAEICwEJAAQHCAAGCAEICwMEBwgABggBCQADAwcIAAgLCwoBCA0CCQALDwEJAAUHCAAGCAEICwMHCBABCwIBCQADBwgACwIBCQALCgEIDQIHCAALAgEJAAQHCAAGCAELCAEDBwgQAgYIAAgLAQECBwgABggBAQcIDAMHCAAGCAEBAQcIAAEGCAABBQEOAQMBBwsJAQgNAwYIAAYIAQgLAQYJAAEHCQACCQAIAwMHCAAJAAgDAQYLAgEJAAEICwIIAQgAAQgMAQgNAQsJAQkAAQYIEAEIAAUIDAgLCAwOCwkBCA0BBggMAgsJAQkABwgQAQsKAQkAAggECQADBwgMCQAJAQIIBgEDCAsICwgLAggFAwIHCAwJAAELCAEJAQEJAQELBwEJAAIJAAMBBgsKAQkAAgcLCQEJAAsJAQkAAwgLAwgLAQsPAQkABggLCAwICwgLAwgMBQgMCAsICwMDAwgMCAsICwMDAwMBBgsIAQkAAQsIAQkAAQYLCQEJAAMHCwkBCQADBwgQAQgEAgYIDAkAAQgGAQgFAQYJAQIICwgLAQcJAQdCYWxhbmNlBkJvcnJvdwRDb2luAklEBEl0ZW0KSXRlbUxpc3RlZAVLaW9zaw1LaW9za093bmVyQ2FwB0xpc3RpbmcETG9jawZPcHRpb24LUHVyY2hhc2VDYXADU1VJDlRyYW5zZmVyUG9saWN5D1RyYW5zZmVyUmVxdWVzdAlUeENvbnRleHQDVUlEA2FkZBBhbGxvd19leHRlbnNpb25zB2JhbGFuY2UGYm9ycm93CmJvcnJvd19tdXQKYm9ycm93X3ZhbBJjbG9zZV9hbmRfd2l0aGRyYXcEY29pbgZkZWxldGUMZGVzdHJveV9zb21lDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQEZW1pdAVldmVudAdleGlzdHNfA2Zvcgxmcm9tX2JhbGFuY2UKaGFzX2FjY2VzcwhoYXNfaXRlbQJpZAxpbnRvX2JhbGFuY2UMaXNfZXhjbHVzaXZlCWlzX2xpc3RlZBVpc19saXN0ZWRfZXhjbHVzaXZlbHkJaXNfbG9ja2VkB2lzX3NvbWUKaXRlbV9jb3VudAdpdGVtX2lkBGpvaW4Fa2lvc2sIa2lvc2tfaWQEbGlzdBZsaXN0X3dpdGhfcHVyY2hhc2VfY2FwBGxvY2sJbWluX3ByaWNlA25ldwtuZXdfcmVxdWVzdAZvYmplY3QGb3B0aW9uBW93bmVyBXBsYWNlDnBsYWNlX2FuZF9saXN0BXByaWNlB3Byb2ZpdHMOcHJvZml0c19hbW91bnQLcHJvZml0c19tdXQIcHVyY2hhc2URcHVyY2hhc2VfY2FwX2l0ZW0ScHVyY2hhc2VfY2FwX2tpb3NrFnB1cmNoYXNlX2NhcF9taW5fcHJpY2URcHVyY2hhc2Vfd2l0aF9jYXAGcmVtb3ZlEHJlbW92ZV9pZl9leGlzdHMTcmV0dXJuX3B1cmNoYXNlX2NhcApyZXR1cm5fdmFsBnNlbmRlchRzZXRfYWxsb3dfZXh0ZW5zaW9ucwlzZXRfb3duZXIQc2V0X293bmVyX2N1c3RvbQNzdWkEdGFrZQ90cmFuc2Zlcl9wb2xpY3kKdHhfY29udGV4dAd1aWRfbXV0EHVpZF9tdXRfYXNfb3duZXIMdWlkX3RvX2lubmVyBXZhbHVlCHdpdGhkcmF3BHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMICgAAAAAAAAADCAsAAAAAAAAAAAIFJAgMPAsJAQgNOAUrDhIBAQICJAgMIAgLAgIEJAgMLwgLLAgLMwMDAgIvCAssCAsEAgEkCAsFAgIkCAsmAQYCASQICwcCAy4ICyQICzsDBwoCCgABAAAmEwoAETY4AAoALhE5SQAAAAAIEgAMAgsAETYOAjgBEgEMAQsCCwECAQEAACwmCwATAAEMBgEMBwwFCwETAQwEDAMOBRE3CwQhBBEFFQsCAQcAJwsGSQAAAAAhBBoFHgsCAQcDJwsDETQLBRE0CwcLAjgCAgIBAAAFFQoALjgBCwEQABQhBAkFDwsAAQsCAQcAJwsCETkLAA8BFQIDAQAABRIKAC44AQsBEAAUIQQJBQ0LAAEHACcLAgsADwEVAgQBAAAFHQoALjgBCwEQABQhBAkFDQsAAQcAJwoAEAIUSQEAAAAWCgAPAhULAA8DDgI4AxIECwI4BAIFAQAABQwKAA8DDgM4AxIGCDgFCwALAQsDOAYCBgEAADNICgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ8gBBYFGgsAAQcIJwoACgIMBC4LBBERIAQjBScLAAEHBCcKAAoCDAUuCwURDgQvBTMLAAEHCycKABACFEkBAAAAFwoADwIVCgAPAwoCCRIFOAcBCwAPAwsCEgQ4CAIHAQAAJSkKAC44AQsBEAAUIQQJBQ0LAAEHACcKAAoCDAQuCwQRESAEFgUaCwABBwQnCgAPAwoCCRIFCgM4CQsALjgBCwILAzkAOAoCCAEAACUNDgI4AwwECgAKAQsCOAYLAAsBCwQLAzgLAgkBAAA5MwoADwMKAQkSBTgMDAQKAA8DCgESBDgIDAMKABACFEkBAAAAFwoADwIVCgQOAjgNIQQbBR8LAAEHAScKAA8ECwI4DjgPAQoADwMKARIGOBABCwMLAQsECwAuOAE4EQIKAQAAPjwKAC44AQoBEAAUIQQJBRELAAELBAELAQEHACcKAAoCDAUuCwURECAEGgUiCwABCwQBCwEBBwYnCwQRNgwKCwAPAwoCCBIFCgM4CQsKDAYLAgwHCwEQABQMCAsDDAkLBgsICwcLCTkBAgsBAAA/MgsBOgEMBgwEDAUMAw4COA0MBwoHCwYmBA4FEgsAAQcBJwoALjgBCwUhBBkFHQsAAQcFJwoADwMKBAgSBTgMAQoADwMKBAkSBQsHOAkLAxE0CwALBAsCOBICDAEAAEAbCwE6AQEMAwwEDAIKAC44AQsEIQQNBRELAAEHBScLAA8DCwMIEgU4DAELAhE0Ag0BAABBMQoALjgBCwEQABQhBAkFDwsAAQsDAQcAJw4COBMEJQsCOBQMBgoGCgAQBDgVJQQcBSILAAELAwEHAicLBgwEBSkKABAEOBUMBAsEDAULAA8ECwULAzgWAg4BAAAFBgsAEAMLARIEOBcCDwEAAAUGCwAQAwsBEgY4GAIQAQAAFRIKABADCgEJEgU4GQQMCwABCAwCBRALAAsBEREMAgsCAhEBAAAFBwsAEAMLAQgSBTgZAhIBAAAFCAsALjgBCwEQABQhAhMBAAAFEAoALjgBCwEQABQhBAkFDQsAAQcAJwsADwMCFAEAAAUSCgAuOAELARAAFCEECQUNCwABBwAnCwILAA8FFQIVAQAABQwKABAFFAQFBQkLAAEHBycLAA8DAhYBAAAFBAsAEAEUAhcBAAAFBAsAEAIUAhgBAAAFBAsAEAQ4FQIZAQAABRAKAC44AQsBEAAUIQQJBQ0LAAEHACcLAA8EAhoBAAAFGwoAOAELARAAFCEECAUMCwABBwAnCgAKAhEOBBEFFQsAAQcLJwsAEAMLAhIEOBoCGwEAAEssCgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ4EFQUZCwABBwsnCgAKAgwELgsEERAgBCIFJgsAAQcJJwsADwMLAhIEOBsCHAEAAEsxCgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ4EFQUZCwABBwsnCgAKAgwELgsEERAgBCIFJgsAAQcJJwoADwMKAhIEOAgLAC44AQsCEgMCHQEAAEsgCwITAwwDDAQKAC44AQsEIQQLBQ8LAAEHBScOATgDCgMhBBUFGQsAAQcKJwsADwMLAxIECwE4BAIeAQAABQQLADcAFAIfAQAABQQLADcBFAIgAQAABQQLADcCFAIBAQACAAMAAAABAAQCAQICAgMGCgcKCAoABXRhYmxlggahHOsLBgAAAA0BAAgCCBADGHMEiwEKBZUBaAf9AacBCKQDIAbEAwoKzgMIC9YDAgzYA+UBDb0FBA7BBQQAEwAKABAAFAAADAIHAQQBAgIEAAMBAgAADwABAgcEAAMCAwIHBAAEBAUCBwQABQYHAgcEABEGCAIHBAAGBAkCBwQADgoLAgcEAA0KCQIHBAAIAQMCBwQACQEDAgcGAQMOAwIHBAEEDwUCBwQBBRAHAgcEAQsPCQIHBAEREAgCBwQCBwwDAAIPAAwACg0LDQwNDg0NDQEHCAIBCwACCQAJAQMHCwACCQAJAQkACQEAAgYLAAIJAAkBCQABBgkBAgcLAAIJAAkBCQABBwkBAQkBAQEBBgsAAgkACQEBAwEIAQIJAAkBAwcIAQkACQECBggBCQACBwgBCQACCAEDBVRhYmxlCVR4Q29udGV4dANVSUQDYWRkBmJvcnJvdwpib3Jyb3dfbXV0CGNvbnRhaW5zBmRlbGV0ZQ1kZXN0cm95X2VtcHR5BGRyb3ANZHluYW1pY19maWVsZBBleGlzdHNfd2l0aF90eXBlAmlkCGlzX2VtcHR5Bmxlbmd0aANuZXcGb2JqZWN0BnJlbW92ZQRzaXplBXRhYmxlCnR4X2NvbnRleHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAAAAgIMCAESAwANAAEAAAMFCwAREAYAAAAAAAAAADkAAgEBAAADDgoANgALAQsCOAAKADcBFAYBAAAAAAAAABYLADYBFQICAQAAAwULADcACwE4AQIDAQAAAwULADYACwE4AgIEAQAACA8KADYACwE4AwwCCgA3ARQGAQAAAAAAAAAXCwA2ARULAgIFAQAAAwULADcACwE4BAIGAQAAAwQLADcBFAIHAQAAAwYLADcBFAYAAAAAAAAAACECCAEAABEOCwA6AAwCDAELAgYAAAAAAAAAACEECQULBwAnCwERDwIJAQAAAwULADoAAREPAgAAAAEADQENAAV0eXBlc2ihHOsLBgAAAAYBAAIDAgYFCAYHDhoIKCAMSAQAAQAAAAEBAgEGCQABARNpc19vbmVfdGltZV93aXRuZXNzBXR5cGVzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQIAAAZib3Jyb3f+BKEc6wsGAAAADQEACAIIGAMgOwRbCgVlUwe4AZ4BCNYCQAaWAxQKqgMTC70DAgy/A30NvAQEDsAEBAAFAQ8ADgATAAMEAQwAAAAAAAECBwEAAAIBBwADBAIAAAwAAQEMAAUCAwEMABAEBQEMAAYBBgEMAQcJBgEAAQgLBgEAAQkPBQEAARIGCQEAAgsMDQEIAwoHCAAHBgUGCAYGBgQGAgkABwgEAQsAAQkAAQcLAAEJAAIJAAgBAwcLAAEJAAkACAEAAQkAAQcIBAEFAQsCAQkAAggDCQABBwsCAQkAAQYJAAEIAwIIAwUCBwsCAQkACQAGQm9ycm93AklEBk9wdGlvbghSZWZlcmVudAlUeENvbnRleHQGYm9ycm93B2Rlc3Ryb3kMZGVzdHJveV9zb21lB2V4dHJhY3QEZmlsbBRmcmVzaF9vYmplY3RfYWRkcmVzcwJpZANuZXcDb2JqBm9iamVjdAZvcHRpb24IcHV0X2JhY2sDcmVmBHNvbWUKdHhfY29udGV4dAV2YWx1ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAACAgsFFAsCAQkAAQICEQUNCAMABgABAAAFBgsBEQkLADgAOQACAQEAAAoOCgA2ADgBDAIOAjgCDAELAgsANwEUCwESAQICAQAADh4LAhMBDAMMBA4BOAILAyEECgUOCwABBwEnCgA3ARQLBCEEFQUZCwABBwAnCwA2AAsBOAMCAwEAAAkHCwA6AAwBAQsBOAQCAAEAAAAGAQYABm9iamVjdLcIoRzrCwYAAAAMAQAIAggMAxR+BJIBBgWYASMHuwH6Agi1BEAG9QRwCuUFCwzwBYICDfIHBA/2BwgAGAEEAAMAHgAABwAAAgQAAwECAAAVAAEAABQAAgAAEwEDAAASAgMAABsEBQAACAYFAAAfBwAAACIHAwAAIQcBAAAgBwIAABYIBQAACQUGAAAPCQMBCAAFCQABCAARCQEBCAAQCQIBCAAGCQcBCAAXAgUAAAoCBgAAGQIGAAEcCQEBAAIOAQIAAw0IAgADGgQCABQCEAoUAwEGCAABCgIBBQEIAAEGCAIBCAEAAQYIAQEHCAIBBgkAAQkAAklECVR4Q29udGV4dANVSUQHYWRkcmVzcwNiY3MJYm9ycm93X2lkCmJvcnJvd191aWQFYnl0ZXMFY2xvY2sGZGVsZXRlC2RlbGV0ZV9pbXBsDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQUZnJlc2hfb2JqZWN0X2FkZHJlc3MKZnJvbV9ieXRlcwJpZAppZF9hZGRyZXNzCGlkX2J5dGVzD2lkX2Zyb21fYWRkcmVzcw1pZF9mcm9tX2J5dGVzDWlkX3RvX2FkZHJlc3MLaWRfdG9fYnl0ZXMDbmV3EW5ld191aWRfZnJvbV9oYXNoBm9iamVjdA5yZWNvcmRfbmV3X3VpZAZzZW5kZXIQc3VpX3N5c3RlbV9zdGF0ZQh0b19ieXRlcwh0cmFuc2Zlcgp0eF9jb250ZXh0DHVpZF9hc19pbm5lcg51aWRfdG9fYWRkcmVzcwx1aWRfdG9fYnl0ZXMMdWlkX3RvX2lubmVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwgAAAAAAAAAAAUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEHBQECAQ8IAAABAAAGBAsAEAA4AAIBAQAABgQLABAAFAICAQAABgQLABEVEQMCAwEAAAYDCwASAAIEAAAABgwLABEXBwMhBAYFCAcCJwcAEgASAQIFAwAABgQHARIAEgECBgEAAAYDCwAQAQIHAQAABgQLABABFAIIAQAABgULABABEAA4AAIJAQAABgULABABEAAUAgoBAAAGBQsAERYSABIBAgsBAAAGBQsAEwETABESAgwBAAAGBQsAOAEQARQCDQEAAAYECwA4ARABAg4BAAAGBQsAOAEQATgCAg8BAAAGBgsAOAEQARAAFAIQAAIAEQMAAAYGCgAREwsAEgASAQISAAIAEwACAAAAAQAACAALAAwAHQAGcHJvdmVyXaEc6wsGAAAABAEAAgcCBwgJIAYpHgAABnByb3ZlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAAdhZGRyZXNzygOhHOsLBgAAAAkBAAoCCggDEj0ETwIFURQHZYEBCOYBQAamAjYM3AJFAAEBAgEDAQsACAEABwADAAcAAA8AAQAABwEAAAAGAgAAAA0AAgAADAADAAAOAAQAAAkFBgAACgUBAAELAgMAAg0HAgEAAwUDBAAEBAICAAkAAQUBDwEKAgEIAAEIAQABAwEGCQAGU3RyaW5nB2FkZHJlc3MFYXNjaWkDYmNzBmVuY29kZQpmcm9tX2FzY2lpCmZyb21fYnl0ZXMJZnJvbV91MjU2A2hleAZsZW5ndGgDbWF4BnN0cmluZw90b19hc2NpaV9zdHJpbmcIdG9fYnl0ZXMJdG9fc3RyaW5nB3RvX3UyNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwggAAAAAAAAAA8g//////////////////////////////////////////8DCAAAAAAAAAAAAAECAAEBAgACAQIAAwEAAAUDDgA4AAIEAQAABQULABEDEQsRCAIFAQAABQQLABEEEQoCBgEAAAUCBwACBwEAAAUCBwECAAdiYWxhbmNlyAehHOsLBgAAAA4BAAQCBBADFFMEZwIFaWMHzAHgAQisAyAGzANKCpYECgugBAQMpATbAg3/BgQOgwcED4cHAgADABAAAQQBAAEAAAQBAAEBAgIAABEAAQEAAA8CAQEAAAUDBAECAAoFBgEAAAYHAQEAABMIBgEAAAsJAQEAAA0KBgEAABILBgEAAAkGCAEAAAQMBgEAAAcNCAEAAAgEAQEAAQwODwAHAwEGCwEBCQABAwEGCwABCQABCQABCwABCQACBwsAAQkAAwELAQEJAAIHCwABCQALAQEJAAACBwsBAQkACwEBCQACBwsBAQkAAwEHCwEBCQACAwYIAgILAQEJAAYIAgEGCAIBBQdCYWxhbmNlBlN1cHBseQlUeENvbnRleHQHYmFsYW5jZRZjcmVhdGVfc3Rha2luZ19yZXdhcmRzDWNyZWF0ZV9zdXBwbHkPZGVjcmVhc2Vfc3VwcGx5F2Rlc3Ryb3lfc3RvcmFnZV9yZWJhdGVzDmRlc3Ryb3lfc3VwcGx5DGRlc3Ryb3lfemVybw9pbmNyZWFzZV9zdXBwbHkEam9pbgZzZW5kZXIFc3BsaXQDc3VpDHN1cHBseV92YWx1ZQp0eF9jb250ZXh0BXZhbHVlDHdpdGhkcmF3X2FsbAR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAREDAQIBEQMAAwEDAAEAAAgECwA3ABQCAQEAAAgECwA3ARQCAgEAAAgDBgAAAAAAAAAAOQACAwEAAAgYCgEG//////////8KADcBFBcjBAkFDQsAAQcBJwoANwEUCgEWCwA2ARULATkBAgQBAAABGAsBOgEMAgoANwEUCgImBAoFDgsAAQcBJwoANwEUCgIXCwA2ARULAgIFAQAACAMGAAAAAAAAAAA5AQIGAQAAAQ8LAToBDAIKADcAFAsCFgoANgAVCwA3ABQCBwEAAAgWCgA3ABQKASYEBwULCwABBwInCgA3ABQKARcLADYAFQsBOQECCAEAAAEICgA3ABQMAQsACwE4AAIJAQAACA0OADcAFAYAAAAAAAAAACEEBwUJBwAnCwA6AQECCgAAAAgLCwERDQcEIQQGBQgHAycLADkBAgsAAAAIDAsBEQ0HBCEEBgUIBwMnCwA6AQECDAMAAAgDCwA6AAIBAAAAAAMBAwAOAAdkaXNwbGF55gqhHOsLBgAAAA0BABACEC4DPoQBBMIBFgXYAcQBB5wD3wII+wVABrsGFArPBiYL9QYGDPsGoAMNmwoGDqEKBgAOAR8AEgAaABsAIAAhACQAAAwBCAEAAQMBCAEACAMBCAEBBAcAAwIHAAMGBAAEAwwABgUCAAcHBwIBAAAAABgAAQEIABkCAQEIAAwAAwEIACMEAwEIAAkFAwEIAAsGAwEIAA8FAwEIAB0HAwEIABcICQEIACUKCwEIABMKDAEIAA0NAQEIAAoFAwEIAhAOAwEDAxgNHAADIhUWAAQUCAkBAAUcEwMBDAYeERIABxEDHgIBAAcWHwMCAQAHHRobAgEACA4LDgAODA4RAQ0XFRkQDg0dExkUGQIGCAYHCAcBCwABCQAEBggGCggDCggDBwgHAAEHCwABCQADBwsAAQkACAMIAwMHCwABCQAKCAMKCAMCBwsAAQkACAMBBggGAQEBBgsAAQkAAQ0BBgsIAggDCAMBBwgHAQkAAwsAAQkAAwMBCAMBBggHAQUCCQAFAg0LCAIIAwgDAQYIBQEIBAELAgEJAAIDAwIIAwgDAgcLCAIJAAkBBgkAAgkACQEBCAUBCwEBCQABCwgCCQAJAQMHCwgCCQAJAQkACQEHRGlzcGxheQ5EaXNwbGF5Q3JlYXRlZAJJRAlQdWJsaXNoZXIGU3RyaW5nCVR4Q29udGV4dANVSUQGVmVjTWFwDlZlcnNpb25VcGRhdGVkA2FkZAxhZGRfaW50ZXJuYWwMYWRkX211bHRpcGxlD2NyZWF0ZV9hbmRfa2VlcA9jcmVhdGVfaW50ZXJuYWwHZGlzcGxheQRlZGl0BGVtaXQFZW1wdHkFZXZlbnQGZmllbGRzDGZyb21fcGFja2FnZQJpZAZpbnNlcnQNaXNfYXV0aG9yaXplZANuZXcPbmV3X3dpdGhfZmllbGRzBm9iamVjdAdwYWNrYWdlD3B1YmxpY190cmFuc2ZlcgZyZW1vdmUGc2VuZGVyBnN0cmluZwh0cmFuc2Zlcgp0eF9jb250ZXh0DHVpZF90b19pbm5lcg51cGRhdGVfdmVyc2lvbgd2ZWNfbWFwB3ZlcnNpb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAAAAgMVCAUTCwgCCAMIAyUNAQIBFQgEAgIDFQgEJQ0TCwgCCAMIAwIOAQ4ADgABAAADCwsAOAAEBAUICwEBBwAnCwE4AQIBAQAADysOAUEQDAYKBg4CQRAhBAkFDwsAAQsDAQcBJwYAAAAAAAAAAAwFCwALAzgCDAQKBQoGIwQpBRoNBA4BCgVCEBQOAgoFQhAUOAMLBQYBAAAAAAAAABYMBQUVCwQCAgEEAAMICwAKATgCCwEuERI4BAIDAQQAFBgKADcAFEgBABYKADYAFQoANwAUDAEKADcBFAwCCwA3AhEPCwELAjkAOAUCBAEEAAMFCwALAQsCOAMCBQEEABgmDgFBEAwECgQOAkEQIQQJBQ0LAAEHAScGAAAAAAAAAAAMAwoDCgQjBCMFFAoADgEKA0IQFA4CCgNCEBQ4AwsDBgEAAAAAAAAAFgwDBQ8LAAECBgEEAAMLCgA2AQ4BOAYBAQsACwELAjgDAgcBBAADBwsANgEOATgGAQECCAEAAAMDCwA4BwIJAQAAAwQLADcAFAIKAQAAAwMLADcBAgsAAAAcDAsAEQ4MAQ4BEQ85ATgICwE4CUgAADkCAgwAAAADBgsANgELAQsCOAoCAAIAAQAAAA4BDgIOAAdlZDI1NTE5aqEc6wsGAAAABgEAAgMCBQUHDAcTFwgqIAxKBAAAAAEAAQADBgoCBgoCBgoCAQEHZWQyNTUxOQ5lZDI1NTE5X3ZlcmlmeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAAHZ3JvdGgxNs0GoRzrCwYAAAAKAQACAgIQAxIyBURMB5AB7QII/QMgBp0EHgq7BCAM2wS0AQ2PBg4ACgAABwAAAQcAAAMHAAACBwAABQABAAAGAAEAABACAwAAEQMEAAAPBQYAAA4FBwAADAgDAAANCQMAABIKCwAAEwwLAAABCAAECgIKAgoCCgIBCAEBCgoCAQoCAQgCAQgDAgYIAAYKAgICBgoCBAYIAAYIAQYIAgYIAwEBBwIGCgIGCgIGCgIGCgIGCgIGCgIFQ3VydmUUUHJlcGFyZWRWZXJpZnlpbmdLZXkLUHJvb2ZQb2ludHMRUHVibGljUHJvb2ZJbnB1dHMWYWxwaGFfZzFfYmV0YV9nMl9ieXRlcwhibHMxMjM4MQVibjI1NAVieXRlcxVkZWx0YV9nMl9uZWdfcGNfYnl0ZXMVZ2FtbWFfZzJfbmVnX3BjX2J5dGVzB2dyb3RoMTYCaWQVcHJlcGFyZV92ZXJpZnlpbmdfa2V5HnByZXBhcmVfdmVyaWZ5aW5nX2tleV9pbnRlcm5hbBdwcm9vZl9wb2ludHNfZnJvbV9ieXRlcx5wdWJsaWNfcHJvb2ZfaW5wdXRzX2Zyb21fYnl0ZXMOcHZrX2Zyb21fYnl0ZXMMcHZrX3RvX2J5dGVzFHZlcmlmeV9ncm90aDE2X3Byb29mHXZlcmlmeV9ncm90aDE2X3Byb29mX2ludGVybmFsFXZrX2dhbW1hX2FiY19nMV9ieXRlcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAAIBCwIBAgQUCgIECgIJCgIICgICAgEHCgIDAgEHCgIAAQAAAAMxABIAAgEBAAAAAzEBEgACAgEAAAAGCwALAQsCCwMSAQIDAQAABBhABQAAAAAAAAAADAENAQ4AEAAURAUNAQ4AEAEURAUNAQ4AEAIURAUNAQ4AEAMURAULAQIEAQAAAAMLABICAgUBAAAAAwsAEgMCBgEAAAAGCwAQBBQLAREHAgcAAgAIAQAAABELABAEFAoBEAAKARABCgEQAgsBEAMLAhAFCwMQBhEJAgkAAgABAAEBAQIBAwAAAgADAAAHcGFja2FnZf8NoRzrCwYAAAALAQAOAg4kAzK3AQTpAQoF8wF2B+kC/gQI5wdABqcIXQqECTAMtAmBBA21DRQAJAEKATIAIQAwADEAMwABDAAABgwAAAgAAAAHAAABAgcAAgQHAAMABwADBQQABQMCAAAOAAEBAgAPAAIBAgAMAQIAABYDBAEAABUDBAEAACcDBQAAKAMFAAA0BgcAADYGCAAANQYJAAAuCgcAAC8KCQAAKQsHAAAqCwcAAC0KDAAAEQIJAAAJAgkAABMCCQAAIg0CAAAjDQIAAB4OAgAACw8QAAAQEQIAACsSAgACFwITAQACGBgZAAIZGBkAAxIXAgADGhUHAQgDGxsHAAMcHxsAAyAWFwAEJhwCAQwFLBobAAYdFQQBAiIUGBQAFCABHA4CCQAHCAgBCAAAAQYIAAEBAQYIBAEGCAEBCAYBAwECAQYIAgEGCAMBBgoCAQcIAQEIAQMHCAECCgIBCAICBwgBCAMCBwgBAgEIBQEJAAEGCQABBwgIAQgHAQYIBQEIBAEGCAgBBQIJAAUCAQgFAggGCAYBBggGAklECVB1Ymxpc2hlcgZTdHJpbmcJVHhDb250ZXh0CFR5cGVOYW1lA1VJRApVcGdyYWRlQ2FwDlVwZ3JhZGVSZWNlaXB0DVVwZ3JhZGVUaWNrZXQPYWRkaXRpdmVfcG9saWN5BWFzY2lpEWF1dGhvcml6ZV91cGdyYWRlDmJ1cm5fcHVibGlzaGVyA2NhcAVjbGFpbQ5jbGFpbV9hbmRfa2VlcA5jb21taXRfdXBncmFkZRFjb21wYXRpYmxlX3BvbGljeQZkZWxldGUPZGVwX29ubHlfcG9saWN5BmRpZ2VzdAtmcm9tX21vZHVsZQxmcm9tX3BhY2thZ2UDZ2V0C2dldF9hZGRyZXNzCmdldF9tb2R1bGUCaWQPaWRfZnJvbV9hZGRyZXNzDWlkX3RvX2FkZHJlc3MTaXNfb25lX3RpbWVfd2l0bmVzcw5tYWtlX2ltbXV0YWJsZQttb2R1bGVfbmFtZQNuZXcGb2JqZWN0Fm9ubHlfYWRkaXRpdmVfdXBncmFkZXMRb25seV9kZXBfdXBncmFkZXMHcGFja2FnZQZwb2xpY3kPcHVibGljX3RyYW5zZmVyEHB1Ymxpc2hlZF9tb2R1bGURcHVibGlzaGVkX3BhY2thZ2ULcmVjZWlwdF9jYXAPcmVjZWlwdF9wYWNrYWdlCHJlc3RyaWN0BnNlbmRlcg10aWNrZXRfZGlnZXN0DnRpY2tldF9wYWNrYWdlDXRpY2tldF9wb2xpY3kIdHJhbnNmZXIKdHhfY29udGV4dAl0eXBlX25hbWUFdHlwZXMPdXBncmFkZV9wYWNrYWdlDnVwZ3JhZGVfcG9saWN5B3ZlcnNpb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAACAQACAYACAcAFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDGggHJAgEHwgEAQIEGggHJAgGNgMlAgICBA0IBiQIBiUCFAoCAwICDQgGJAgGAAEAABMSDgA4AAQEBQgLAQEHACc4AQwCCwERHw4CERkOAhEaEgACAQEAAAIICwAKATgCCwEuESE4AwICAQAAAgYLABMAAQERGwIDAQAAEwk4AQwBDgERGQsAEAAUIQIEAQAAHRc4AQwCDgIRGQoAEAAUIQQRDgIRGgsAEAEUIQwBBRULAAEJDAELAQIFAQAAAgMLABABAgYBAAACAwsAEAACBwEAAAIECwAQAhQCCAEAAAIECwAQAxQCCQEAAAIECwAQBBQCCgEAAAIECwAQBRQCCwEAAAIECwAQBhQCDAEAAAIECwAQBxQCDQEAAAIECwAQCBQCDgEAAAIDCwAQCQIPAQAAAgIHBQIQAQAAAgIHBgIRAQAAAgIHBwISAQQAAgQLAAcGERcCEwEEAAIECwAHBxEXAhQBBAACBwsAEwEBAQERGwIVAQAAHikHCBEdDAMKABACFAoDIgQKBQ4LAAEHAicKAQoAEAQUJgQVBRkLAAEHAScKABACFAwECwMKAA8CFQsALjgECwQLAQsCEgICFgEAAB4nCwETAwwDDAIKAC44BAsCIQQLBQ8LAAEHBCcKABACER4HCCEEFgUaCwABBwMnCwMKAA8CFQoAEAMUBgEAAAAAAAAAFgsADwMVAhcAAAACEAoAEAQUCgElBAcFCwsAAQcBJwsBCwAPBBUCAAEAAgEBAQIBAwIBAgIDAAMBAgMAB3ZlY19tYXC4DaEc6wsGAAAADQEABgIGFgMcqAEExAEcBeAB/gEH3gOZAgj3BUAGtwYyCukGFQv+BgQMggfrBQ3tDAYO8wwGAB4BFQEfAAIHAgEAAAAAAAcCAQAAAAEBBwEAAAAHAAECAQAADgIAAgEAABcDBAIBAAAWBQQCAQAADQMGAgEAAAgHCAIBAAAcBwkCAQEAAwcKAgEAABoLDAIBAAAQCwoCAQAABQEAAgEAAA8BDQIBAAATCw4CAQAADAcPAgEAAAsHDAIBAAAJEBECAQAAChITAgEAABgSBAIBAAEGGxgBAAERHAoBAAEUABsBAAEbGBsBAAIQGQoBAAIXFxgBAAIZHwABAAcEDgQXFBYUBQQVGhQaDQQTDAgEGBQVDBQMEgwAAQsAAgkACQEDBwsAAgkACQEJAAkBAgcLAAIJAAkBBgkAAgkACQEBBwsAAgkACQEBBwkBAgYLAAIJAAkBBgkAAQYJAQELAgEJAQEBAQYLAAIJAAkBAQMCCgkACgkBAQoJAAELAgEDAgYLAAIJAAkBAwIGCQAGCQECBwsAAgkACQEDAgYJAAcJAQELAQIJAAkBAQYJAAIGCQADAgcKCQADAQkAAQYKCQABCQEBCwIBCQABBgsCAQkAAQoLAQIJAAkBBwoLAQIJAAkBAwkACgkAAwkBCgkBAQcKCQAEBgsBAgkACQEDCgkAAwIDAwEGCwECCQAJAQEHCwECCQAJAQVFbnRyeQZPcHRpb24GVmVjTWFwCGNvbnRhaW5zCGNvbnRlbnRzDWRlc3Ryb3lfZW1wdHkMZGVzdHJveV9zb21lBWVtcHR5A2dldBBnZXRfZW50cnlfYnlfaWR4FGdldF9lbnRyeV9ieV9pZHhfbXV0B2dldF9pZHgLZ2V0X2lkeF9vcHQHZ2V0X211dAZpbnNlcnQQaW50b19rZXlzX3ZhbHVlcwhpc19lbXB0eQdpc19zb21lA2tleQRrZXlzBG5vbmUGb3B0aW9uA3BvcAZyZW1vdmUTcmVtb3ZlX2VudHJ5X2J5X2lkeAdyZXZlcnNlBHNpemUEc29tZQd0cnlfZ2V0BXZhbHVlB3ZlY19tYXAGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAAIBBAoLAQIJAAkBAQICEgkAHQkBAAQBBAABAAAAA0AUAAAAAAAAAAA5AAIBAQAAFRQKAA4BDAMuCwM4ACAECQUNCwABBwAnCwA2AAsBCwI5AUQUAgIBAAAWDQoACwEMAi4LAjgBDAMLADYACwM4AjoBAgMBAAAADwoANwA4AyAEBgUKCwABBwQnCwA2AEUUOgECBAEAABYNCgALAQwCLgsCOAEMAwsANgALA0MUNgECBQEAAAwKCgALATgBDAILADcACwJCFDcBAgYBAAAJEwoACgE4AAQLCwALATgEFDgFDAIFEQsAAQsBATgGDAILAgIHAQAADwcLAAsBOAcMAg4COAgCCAEAAAAECwA3AEEUAgkBAAAABQsAOAkGAAAAAAAAAAAhAgoBAAAdDAsAOgAMAQ4BOAMEBwUJBwInCwFGFAAAAAAAAAAAAgsBAAAeKAsAOgAMAQ0BOAoGAAAAAAAAAAAMAg4BQRQMBUAYAAAAAAAAAAAMBEAaAAAAAAAAAAAMBwoCCgUjBCMFEw0BRRQ6AQwGDAMNBAsDRBgNBwsGRBoLAgYBAAAAAAAAABYMAgUOCwFGFAAAAAAAAAAACwQLBwIMAQAAICAGAAAAAAAAAAAMAgoANwBBFAwEQBgAAAAAAAAAAAwDCgIKBCMEHAUNCgA3AAoCQhQMAQ0DCwE3AhREGAsCBgEAAAAAAAAAFgwCBQgLAAELAwINAQAAISQGAAAAAAAAAAAMAgoAOAkMAwoCCgMjBB4FCgoANwAKAkIUNwIKASEEGQsAAQsBAQsCOAsCCwIGAQAAAAAAAAAWDAIFBQsAAQsBATgMAg4BAAAPDQsACwE4BwwCDgI4CAQIBQoHAScLAjgNAg8BAAAiFAoBCgA4CSMEBgUKCwABBwMnCwA3AAsBQhQMAgoCNwILAjcBAhABAAAjFQoBCgAuOAkjBAcFCwsAAQcDJwsANgALAUMUDAIKAjcCCwI2AQIRAQAAABEKAQoALjgJIwQHBQsLAAEHAycLADYACwE4AjoBAgAAAQEBAAAEAQQCBAAHdmVjX3NldK0GoRzrCwYAAAANAQAGAgYMAxJgBHIUBYYBWgfgAZ8BCP8CQAa/AxQK0wMHC9oDAgzcA5ECDe0FAg7vBQIAEgENARMAAQcBAwABAAcBAAAABQABAQMADwIBAQMACAMAAQMADgQAAQMAAgUGAQMAEAcIAQMACgcGAQMACQEJAQMABwUKAQMABgUIAQMBBBACAQABCw4GAQABDAAQAQABEQIQAQACDg0CAQACDwIJAQAPAgQCCQIOAggCCwgFAg0IDAgKCAABCwABCQABCQACBwsAAQkACQACBwsAAQkABgkAAgYLAAEJAAYJAAEBAQYLAAEJAAEDAQoJAAELAQEDAQYJAAIGCQADAgcKCQADAQYLAQEJAAIDAwELAQEJAAZPcHRpb24GVmVjU2V0CGNvbnRhaW5zCGNvbnRlbnRzDGRlc3Ryb3lfc29tZQVlbXB0eQdnZXRfaWR4C2dldF9pZHhfb3B0Bmluc2VydAlpbnRvX2tleXMIaXNfZW1wdHkHaXNfc29tZQRub25lBm9wdGlvbgZyZW1vdmUJc2luZ2xldG9uBHNpemUEc29tZQd2ZWNfc2V0BnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAACAQMKCQAAAgABAAAAA0ACAAAAAAAAAAA5AAIBAQAAAAQLADgAOQACAgEAAAsSCgAOAQwCLgsCOAEgBAkFDQsAAQcAJwsANgALAUQCAgMBAAAMDQoACwEMAi4LAjgCDAMLADYACwM4AwECBAEAAAoHCwALATgEDAIOAjgFAgUBAAAABAsANwBBAgIGAQAAAAULADgGBgAAAAAAAAAAIQIHAQAAAAMLADoAAggAAAAPIwYAAAAAAAAAAAwCCgA4BgwDCgIKAyMEHQUKCgA3AAoCQgIKASEEGAsAAQsBAQsCOAcCCwIGAQAAAAAAAAAWDAIFBQsAAQsBATgIAgkAAAAKDQsACwE4BAwCDgI4BQQIBQoHAScLAjgJAgAAAAIACGJsczEyMzgxlAGhHOsLBgAAAAYBAAIDAgoFDAwHGDgIUCAMcAgAAAACAAEAAAEAAQADBgoCBgoCBgoCAQEIYmxzMTIzODEWYmxzMTIzODFfbWluX3BrX3ZlcmlmeRdibHMxMjM4MV9taW5fc2lnX3ZlcmlmeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAEBAgAACGVjZHNhX2sx1AGhHOsLBgAAAAcBAAIDAg8FERwHLUAIbSAGjQEaDKcBDAABAAIAAQAAAAIBAAADAwQAAwYKAgYKAgIBCgIBBgoCBAYKAgYKAgYKAgIBARFkZWNvbXByZXNzX3B1YmtleQhlY2RzYV9rMRNzZWNwMjU2azFfZWNyZWNvdmVyEHNlY3AyNTZrMV92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAgEAAgEBAAECAAEBAgACAQIAAAhlY2RzYV9yMbQBoRzrCwYAAAAHAQACAwIKBQwYByQuCFIgBnIaDIwBCAAAAAEAAQAAAgIDAAMGCgIGCgICAQoCBAYKAgYKAgYKAgIBAQhlY2RzYV9yMRNzZWNwMjU2cjFfZWNyZWNvdmVyEHNlY3AyNTZyMV92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAgEAAgEBAAECAAEBAgAACHRyYW5zZmVy+AKhHOsLBgAAAAgBAAIDAjYEOAYFPggHRpABCNYBIAb2AQoMgAJSAAcABwABAQgABAABAQwAAAIBAQgAAgIBAQwABQIBAQgAAwIBAQwAAQIBAQgABgIBAQgACAABAQgIAgYCBwICCQAFAAEJAA1mcmVlemVfb2JqZWN0EmZyZWV6ZV9vYmplY3RfaW1wbBRwdWJsaWNfZnJlZXplX29iamVjdBNwdWJsaWNfc2hhcmVfb2JqZWN0D3B1YmxpY190cmFuc2ZlcgxzaGFyZV9vYmplY3QRc2hhcmVfb2JqZWN0X2ltcGwIdHJhbnNmZXINdHJhbnNmZXJfaW1wbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAABAAABBAsACwE4AAIBAQAAAQQLAAsBOAACAgEAAAEDCwA4AQIDAQAAAQMLADgBAgQBAAABAwsAOAICBQEAAAEDCwA4AgIGAwIABwMCAAgDAgAACXRhYmxlX3ZlY7IGoRzrCwYAAAANAQAGAgYSAxhnBH8UBZMBigEHnQKfAQi8AyAG3AMUCvADCgv6AwIM/AP1AQ3xBQIO8wUCABEAEAASAAEEAQQBAQAMAgcBBAECAgIAAAgAAQEEAA8CAQEEAAoDBAEEAAkDBQEEAAQGBwEEAA0ICQEEAAUKCwEEAAwMDQEEAAcBCQEEAQMTCQIHBAEEERICBwQBBRQVAgcEAQcPCQIHBAEKEAQCBwQBCwAPAgcEAQ4UFgIHBA4OAA0FDQ0OAg0KDgkOCw4PDgwOAQcIAgELAAEJAAIJAAcIAgEGCwABCQABAwEBAgYLAAEJAAMBBgkAAgcLAAEJAAkAAAIHCwABCQADAQcJAAEHCwABCQABCQACAwkAAQsBAgkACQEBBgsBAgkACQECBgsBAgkACQEJAAEGCQEDBwsBAgkACQEJAAkBAgcLAQIJAAkBCQABBwkBAQkBBVRhYmxlCFRhYmxlVmVjCVR4Q29udGV4dANhZGQGYm9ycm93CmJvcnJvd19tdXQIY29udGVudHMNZGVzdHJveV9lbXB0eQVlbXB0eQhpc19lbXB0eQZsZW5ndGgDbmV3CHBvcF9iYWNrCXB1c2hfYmFjawZyZW1vdmUJc2luZ2xldG9uBXRhYmxlCXRhYmxlX3ZlYwp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAACAQYLAQIDCQAADQABAAAJBAsAOAA5AAIBAQAAAQgLATgBDAINAgsAOAILAgICAQAACQQLADcAOAMCAwEAAAkFCwA4BAYAAAAAAAAAACECBAEAAAkPCgA4BAoBJAQGBQoLAAEHACcLADcACwE4BQIFAQAABAoKAC44BAwCCwA2AAsCCwE4BgIGAQAACRAKAC44BAoBJAQHBQsLAAEHACcLADYACwE4BwIHAQAABBQKAC44BAwBCgEGAAAAAAAAAAAkBAkFDQsAAQcAJwsANgALAQYBAAAAAAAAABc4CAIIAQAACQwOADgEBgAAAAAAAAAAIQQGBQgHAScLADoAOAkCAAAADQAJdmVyc2lvbmVk/gWhHOsLBgAAAAsBAAgCCBQDHFUEcQoFe2EH3AHsAQjIAyAG6AMKCvIDEAyCBMUBDccFBAAXAAsAEAAUAAQMAAADAAACAAcAAgIEAAMBAgAACAABAQQAFgIDAAANAgQBBAAOBQYBBAATBQcBBAAVCAkBBAAKAQoBBAEFDgkCBwQBBg8QAgcEAQcREgIHBAESERMCBwQCCQwJAAIMBBQBCAIPCwwABw0IDQkNCg0MAQMDCQAHCAQBCAABBggAAQMBBgkAAQcIAAEHCQACCQAIAQQHCAADCQAIAQABCQABBwgEAQgDAgMJAAMHCAMJAAkBAgYIAwkAAQYJAQIHCAMJAAEHCQEBCQEBCAIDCAMJAAMCSUQJVHhDb250ZXh0A1VJRBBWZXJzaW9uQ2hhbmdlQ2FwCVZlcnNpb25lZANhZGQGYm9ycm93CmJvcnJvd19tdXQGY3JlYXRlBmRlbGV0ZQdkZXN0cm95DWR5bmFtaWNfZmllbGQCaWQKbG9hZF92YWx1ZQ5sb2FkX3ZhbHVlX211dANuZXcGb2JqZWN0C29sZF92ZXJzaW9uBnJlbW92ZRhyZW1vdmVfdmFsdWVfZm9yX3VwZ3JhZGUKdHhfY29udGV4dAd1cGdyYWRlB3ZlcnNpb24JdmVyc2lvbmVkDHZlcnNpb25lZF9pZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAACAgwIAxYDAQICGAgCEQMAAQAAAQwLAhENCgASAAwDDQMPAAsACwE4AAsDAgEBAAAJBAsAEAEUAgIBAAAJBwoAEAALABABFDgBAgMBAAAJBwoADwALABABFDgCAgQBAAAJDgoADwAKABABFDgDCgAuOAQLABABFBIBAgUBAAADIAsDEwEMBAoALjgEIQQJBQ0LAAEHACcLBAoBIwQSBRYLAAEHACcKAA8ACgELAjgACwELAA8BFQIGAQAAFQwLABMADAMMAQ0BCwM4AwwCCwERCwsCAgAAAAEACm9iamVjdF9iYWfpBqEc6wsGAAAACwEACgIKFgMgfAScAQ4FqgFYB4IC5wEI6QNABqkECgqzBAgMuwT1AQ2wBgQAFAEVAAwAEwAYAAEMAAECBwEAAAMABwADBAQABAMCAAASAAEAAAUCAwIHDAAGBAUCBwwABwYHAgcMABYGCAIHDAAIBAkBBwAJBAkCBwwAEQoLAAAQCgkAAAsBAwAAGQQMAQcCBQ8DAgcMAgYQBQIHDAIHEQcCBwwCDRAJAQcCDhAJAgcMAg8QDAEHAhYRCAIHDAMKDQMAAxIADQALDgwODQ4RDg4SDw4QEgEHCAQBCAADBwgACQAJAQACBggACQABBgkBAgcIAAkAAQcJAQEJAQEBAQYIAAEDAQsBAQgCAQgDAgkACQEDBwgDCQAJAQIGCAMJAAIHCAMJAAEJAAIIAwMCSUQJT2JqZWN0QmFnBk9wdGlvbglUeENvbnRleHQDVUlEA2FkZAZib3Jyb3cKYm9ycm93X211dAhjb250YWlucxJjb250YWluc193aXRoX3R5cGUGZGVsZXRlDWRlc3Ryb3lfZW1wdHkUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlAmlkCGlzX2VtcHR5Bmxlbmd0aANuZXcGb2JqZWN0Cm9iamVjdF9iYWcGb3B0aW9uBnJlbW92ZQRzaXplCnR4X2NvbnRleHQIdmFsdWVfaWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAACAg8IAxcDAAEAAAMFCwAREwYAAAAAAAAAABIAAgEBAAADDgoADwALAQsCOAAKABABFAYBAAAAAAAAABYLAA8BFQICAQAAAwULABAACwE4AQIDAQAAAwULAA8ACwE4AgIEAQAACA8KAA8ACwE4AwwCCgAQARQGAQAAAAAAAAAXCwAPARULAgIFAQAAAwULABAACwE4BAIGAQAAAwULABAACwE4BQIHAQAAAwQLABABFAIIAQAAAwYLABABFAYAAAAAAAAAACECCQEAABMOCwATAAwCDAELAgYAAAAAAAAAACEECQULBwAnCwEREgIKAQAAAwULABAACwE4BgIAAAABAAp0eF9jb250ZXh0+QKhHOsLBgAAAAoBAAICAgQDBh4FJBQHOGgIoAEgBsABFArUAQ4M4gFgDcICCgAHAAACAAAGAAEAAAIAAgAAAwACAAAEAwEAAAUAAgAAAQQBAAEGCAABBQEDAQcIAAIKAgMAAgUDCVR4Q29udGV4dAlkZXJpdmVfaWQFZXBvY2gSZXBvY2hfdGltZXN0YW1wX21zFGZyZXNoX29iamVjdF9hZGRyZXNzC2lkc19jcmVhdGVkBnNlbmRlcgp0eF9jb250ZXh0B3R4X2hhc2gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIIAAAAAAAAAADCAAAAAAAAAAAAAIFBgUICgICAwMDBQMAAQAABQQLABAAFAIBAQAABQQLABABFAICAQAABQQLABACFAIDAQAABhIKABADFAwCCgAQBBQKAhEFDAELAgYBAAAAAAAAABYLAA8DFQsBAgQAAAAFBAsAEAMUAgUAAgAAAAACAAMABAABAAxsaW5rZWRfdGFibGWRDaEc6wsGAAAADQEACgIKHgMo1AEE/AEcBZgCvAEH1APNAgihBkAG4QYUCvUGJgubBwQMnweXBQ22DA4OxAwOABgBHQAOABwAKAAADAIHAAQBAAEEAgcABAABAgcBAAADBAQABAMCAAAZAAECBwQAEQIDAgcEAAYCAwIHBAAiBAUCBwQAIQQFAgcEAAcGBwIHBAAICAkCBwQAIAYDAgcEABoGAwIHBAAjCAoCBwQAHwsMAgcEAB4LDAIHBAAJBg0CBwQAFwIOAgcEABQCDQIHBAALAQUCBwQADQEFAgcGAQcDGQEAAQwREAEAARATBQEAARUDDQEAARYDDQEAARsFEQEAASUQEQEAASYTEQEAAgUWBQIHBAIHFwcCBwQCCBUJAgcEAg8XDQIHBAIjFQoCBwQDCg8FAAMZAA8AFhAYEBQQExAVEBIQFxAbFBkUGhQdFBEQCQwcFAEHCAQBCwACCQAJAQEGCwACCQAJAQEGCwIBCQADBwsAAgkACQEJAAkBAAIGCwACCQAJAQkAAQYJAQIHCwACCQAJAQkAAQcJAQEJAQEHCwACCQAJAQIJAAkBAQEBAwEIAwEJAAELAgEJAAULAgEJAAsCAQkACwIBCQAJAAsCAQkAAgcLAgEJAAkAAgkACwECCQAJAQIHCAMJAAMHCAMJAAkBAgYIAwkAAwsCAQkACwIBCQAJAQEGCQACCAMDC0xpbmtlZFRhYmxlBE5vZGUGT3B0aW9uCVR4Q29udGV4dANVSUQDYWRkBGJhY2sGYm9ycm93CmJvcnJvd19tdXQIY29udGFpbnMGZGVsZXRlDWRlc3Ryb3lfZW1wdHkMZGVzdHJveV9zb21lBGRyb3ANZHluYW1pY19maWVsZBBleGlzdHNfd2l0aF90eXBlBGZpbGwFZnJvbnQEaGVhZAJpZAhpc19lbXB0eQdpc19ub25lB2lzX3NvbWUGbGVuZ3RoDGxpbmtlZF90YWJsZQNuZXcEbmV4dARub25lBm9iamVjdAZvcHRpb24IcG9wX2JhY2sJcG9wX2Zyb250BHByZXYJcHVzaF9iYWNrCnB1c2hfZnJvbnQGcmVtb3ZlBHNpemUEc29tZQxzd2FwX29yX2ZpbGwEdGFpbAp0eF9jb250ZXh0BXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAAIEEwgDJAMSCwIBCQAnCwIBCQABAgMgCwIBCQAaCwIBCQApCQEADAEMAAEAAAUHCwARHwYAAAAAAAAAADgAOAA5AAIBAQAABQMLADcAAgIBAAAFAwsANwECAwEAABI2CgA2AAoBOAEMBQoANwE4AgQNCgA2AQoBOAM4AAwHDgU4BAQhCwU4BQwGCgE4BgoANgIKBjgHNgMVCwY4BgwDBSM4AAwDCwMMBAoANgILAQsHCwQLAjkBOAgKADcEFAYBAAAAAAAAABYLADYEFQIEAQAAEjYKADcAOAIECAoANgAKATgDCgA2AQoBOAEMBQ4FOAQEHwsFOAUMBgoBOAYKADYCCgY4BzYFFQsGOAYMAwUhOAAMAwsDDAc4AAwECgA2AgsBCwcLBAsCOQE4CAoANwQUBgEAAAAAAAAAFgsANgQVAgUBAAAFBgsANwILATgJNwYCBgEAAAUGCwA2AgsBOAc2BgIHAQAABQYLADcCCwE4CTcDAggBAAAFBgsANwILATgJNwUCCQEAABhBCgA2AgoBOAo6AQwEDAIMAwoANwQUBgEAAAAAAAAAFwoANgQVDgM4BAQcCgIKADYCDgM4CxQ4BzYFFQ4COAQEKAoDCgA2Ag4COAsUOAc2AxUKADcAOAsOASEEMgsCCgA2ABUKADcBOAsOASEEPQsDCwA2ARUFPwsAAQsEAgoBAAAQEwoANwA4BAQFBQkLAAEHAScKADcAOAsUDAEKAQsACwE4DAILAQAAEBMKADcBOAQEBQUJCwABBwEnCgA3ATgLFAwBCgELAAsBOAwCDAEAAAUFCwA3AgsBOA0CDQEAAAUECwA3BBQCDgEAAAUGCwA3BBQGAAAAAAAAAAAhAg8BAAAaEAsAOgABAQwCDAELAgYAAAAAAAAAACEECwUNBwAnCwERHgIQAQAABQcLADoAAQEBER4CAAIAAwAAAQAAAQEBAQIADAEMAgwDDAQMBQwGDAAMb2JqZWN0X3RhYmxl3wahHOsLBgAAAA0BAAoCChoDJHgEnAEMBagBcQeZAscBCOADQAagBAoKqgQIC7IEAgy0BOYBDZoGBA6eBgQAEgETAAsAEQAWAAEMAgcBDAEBAgcBAAADAAcAAwQEAAQDAgAAEAABAgcMAAUCAwIHDAAGBAUCBwwABwYHAgcMABQGCAIHDAAIBAkCBwwADwoLAgcMAA4KCQIHDAAKAQMCBwwAFwQMAgcMAgUPAwIHDAIGEAUCBwwCBxEHAgcMAgwQCQEHAg0QDAEHAhQRCAIHDAMJDQMAAxAADQAKDgsODA4PDg0SDhIBBwgEAQsAAgkACQEDBwsAAgkACQEJAAkBAAIGCwACCQAJAQkAAQYJAQIHCwACCQAJAQkAAQcJAQEJAQEBAQYLAAIJAAkBAQMBCwEBCAIBCAMCCQAJAQMHCAMJAAkBAgYIAwkAAgcIAwkAAQkAAggDAwJJRAtPYmplY3RUYWJsZQZPcHRpb24JVHhDb250ZXh0A1VJRANhZGQGYm9ycm93CmJvcnJvd19tdXQIY29udGFpbnMGZGVsZXRlDWRlc3Ryb3lfZW1wdHkUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXwJpZAhpc19lbXB0eQZsZW5ndGgDbmV3Bm9iamVjdAxvYmplY3RfdGFibGUGb3B0aW9uBnJlbW92ZQRzaXplCnR4X2NvbnRleHQIdmFsdWVfaWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAACAg0IAxUDAA4AAQAAAwULABERBgAAAAAAAAAAOQACAQEAAAMOCgA2AAsBCwI4AAoANwEUBgEAAAAAAAAAFgsANgEVAgIBAAADBQsANwALATgBAgMBAAADBQsANgALATgCAgQBAAAIDwoANgALATgDDAIKADcBFAYBAAAAAAAAABcLADYBFQsCAgUBAAADBQsANwALATgEAgYBAAADBAsANwEUAgcBAAADBgsANwEUBgAAAAAAAAAAIQIIAQAAEw4LADoADAIMAQsCBgAAAAAAAAAAIQQJBQsHACcLAREQAgkBAAADBQsANwALATgFAgAAAAEADgEOAA1keW5hbWljX2ZpZWxklgqhHOsLBgAAAA4BAAYCBhYDHIUBBKEBGAW5AagBB+ECgQMI4gVABqIGKArKBgwL1gYCDNgG6wINwwkGDskJCA/RCQIACwEaABkAAAgCBwAEAAECBwEAAAIBBwACAwQAAAQAAQIHBAAGAgMCBwQACQQFAgcEABsEBgIHBAANAgcBBwAdBAgCBwQADgIHAgcEAA8CCQEHABAECgEHABMLDAEHAAULAQEIAAcJDQEIAAgKDgEIABwPEAEIABEPBwAAEg8HAQgBGAEYAQABHhAYAQACChMBAAIVHAwAAhcMEwACHxIMAAkQChULFQwVDRUEEAMUEQYQBg8VCxoMGgMHCAMJAAkBAAIGCAMJAAEGCQECBwgDCQABBwkBAQkBAQEBCwEBCQECBggDBQIHCAMFAgUJAAEFAQYJAAEHCQACBQUBCQADCwACCQAJAQUFAQYIAwEIAwIJAAkBAQsAAgkACQEDBQUJAQIJAAsBAQkBAQsBAQkABAYLAAIJAAgCBQYIAwYIAgELAAIJAAgCAgkACAIBBggCBAcLAAIJAAgCBQcIAwcIAgVGaWVsZAJJRAZPcHRpb24DVUlEA2FkZBBhZGRfY2hpbGRfb2JqZWN0BmJvcnJvdxNib3Jyb3dfY2hpbGRfb2JqZWN0F2JvcnJvd19jaGlsZF9vYmplY3RfbXV0CmJvcnJvd19tdXQGZGVsZXRlDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlCmZpZWxkX2luZm8OZmllbGRfaW5mb19tdXQQaGFzX2NoaWxkX29iamVjdBhoYXNfY2hpbGRfb2JqZWN0X3dpdGhfdHkRaGFzaF90eXBlX2FuZF9rZXkCaWQNaWRfdG9fYWRkcmVzcwRuYW1lEW5ld191aWRfZnJvbV9oYXNoBG5vbmUGb2JqZWN0Bm9wdGlvbgZyZW1vdmUTcmVtb3ZlX2NoaWxkX29iamVjdBByZW1vdmVfaWZfZXhpc3RzBHNvbWUOdWlkX3RvX2FkZHJlc3MFdmFsdWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAACAxQIAxYJACAJAQAUAAEAABEaCwAuERUMBQoFCgE4AAwECgUKBBEOIAQOBRAHACcLBBEUCwELAjkADAMLBQsDOAECAQEAAAwKCgARFQsBOAAMAgsACwI4AjcAAgIBAAAMCwoALhEVCwE4AAwCCwALAjgDNgACAwEAABYRCwAuERUMAwoDCwE4AAwCCwMLAjgEOgAMBAEREgsEAgQBAAAPCwsAERUMAwoDCwE4AAwCCwMLAhEOAgUBAAAXEwoACgEMAi4LAjgFBA0LAAsBOAY4BwwDBRELAAE4CAwDCwMCBgEAAA8LCwARFQwDCgMLATgADAILAwsCOAkCBwMAABkWCgARFQsBOAAMAwsACwM4CgwCCgI3AQwECgI3AgELAjcDDAULBAsFERMCCAMAAB0YCgAuERULATgADAMLAAsDOAsMAgoCNgEMBAoCNgIBCwI2AwwFCwQLBS4REwIJAwIACgMCAAsDAgAMAwIADQMCAA4DAgAPAwIAAAIAAAABABQBGwIbABsADAAOcHJpb3JpdHlfcXVldWXQCqEc6wsGAAAADQEABAIEDAMQPARMCgVWpwEH/QG4AQi1A0AG9QMOCoMEEguVBAQMmQTzBQ2MCgQOkAoEAAsBEAABBgECAAAABgECAAAGAAEBAgAIAgMBAgAEBAUBAgAHAwYBAgACBwABAgANCAUBAgAFCQUBAgAJCgsBAgEMDw0BAAEODw0BAAYNCQYFDQgQCA0BCgsBAQkAAQsAAQkAAQcLAAEJAAIDCQADBwsAAQkAAwkAAAELAQEJAAIKAwoJAAIHCgsBAQkAAwMHCgsBAQkAAwMBBgsAAQkAAQoDAgMDAQkAAwMDCQACBwoJAAMBAwUDAwMKCwEBCQAJAAUHCgsBAQkAAwcKCwEBCQADAw0HCgsBAQkAAQMHCgsBAQkAAwEHCgsBAQkAAwcKCwEBCQADAwMDAgMKAwVFbnRyeQ1Qcmlvcml0eVF1ZXVlDmNyZWF0ZV9lbnRyaWVzB2VudHJpZXMGaW5zZXJ0FW1heF9oZWFwaWZ5X3JlY3Vyc2l2ZQNuZXcJbmV3X2VudHJ5B3BvcF9tYXgKcHJpb3JpdGllcwhwcmlvcml0eQ5wcmlvcml0eV9xdWV1ZQZyZW1vdmUWcmVzdG9yZV9oZWFwX3JlY3Vyc2l2ZQtzd2FwX3JlbW92ZQV2YWx1ZQZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAoDAQAAAgEDCgsBAQkAAQICCgMPCQAADQENAAEAAAwYDgBBBgwCCgIGAgAAAAAAAAAaDAEKAQYAAAAAAAAAACQEFQUMCwEGAQAAAAAAAAAXDAENAAoCCgE4AAUHCwA5AAIBAQAADh4KADcAQQYMAQoBBgAAAAAAAAAAJAQJBQ0LAAEHACcKADYABgAAAAAAAAAAOAE6AQwDDAILADYACwEGAQAAAAAAAAAXBgAAAAAAAAAAOAALAgsDAgIBAAAQEQoANgALAQsCOQFEBgoANwBBBgYBAAAAAAAAABcMAwsANgALAzgCAgMBAAAFBAsACwE5AQIEAQAAESgOAEEQDAMOAUENCgMhBAkFCwYAAAAAAAAAACdABgAAAAAAAAAADAUGAAAAAAAAAAAMAgoCCgMjBCYFFA0ABgAAAAAAAAAAOAMMBA0BBgAAAAAAAAAAOAQMBg0FCwQLBjkBRAYLAgYBAAAAAAAAABYMAgUPCwUCBQAAABIuCgEGAAAAAAAAAAAhBAcLAAECCgEGAQAAAAAAAAAXBgIAAAAAAAAAGgwGCgAKAQwDDAIKAAoGDAUMBAsCLgsDQgY3ARQLBC4LBUIGNwEUJAQrCgALAQoGRwYLAAsGOAIFLQsAAQIGAAAAE24KAQYAAAAAAAAAACEEBwsAAQIKAgoBIwQMBRALAAEGAQAAAAAAAAAnCgIGAgAAAAAAAAAYBgEAAAAAAAAAFgwNCg0GAQAAAAAAAAAWDA8KAgwOCg0KASMENwoACg0MBQwDCgAKDgwHDAYLAy4LBUIGNwEUCwYuCwdCBjcBFCQMCAU5CQwICwgEPQsNDA4KDwoBIwRYCgAKDwwKDAkKAAoODAwMCwsJLgsKQgY3ARQLCy4LDEIGNwEUJAwEBVoJDAQLBAReCw8MDgoOCgIiBGsKAAoOCwJHBgsACwELDjgABW0LAAECBwEAABQcBwEMAgYAAAAAAAAAAAwBCgEKADcAQQYjBBgFCw0CCgA3AAoBQgY3ARREEAsBBgEAAAAAAAAAFgwBBQQLAAELAgIAAAEAAA0BDQAPdHJhbnNmZXJfcG9saWN5+xGhHOsLBgAAAA0BABgCGE4DZvMBBNkCKgWDA5YDB5kG5QQI/gpABr4LPAr6CzcLsQwKDLsM4QQNnBEQDqwREAA7AS8BPQATABUAHAAfAC4AMAA5ADwAQgAKAAEAAQAHDAEAAQAIDAEAAQAJAwEAAQAFBwECAQEDBwEAAAIMBwADAAQBAAEEAQwBAAEHAgcABw0EAAgEDAAJBgIACgsCAAsOBwEDAAAtAAEBAAAsAgMBAABDBAUBAAAZBgUBAAAWBwABAAARCAkDAAIGACUKCwMAAgYAEgwJAgACABANCQIAAgAmDg8CAAIANhAJAwACBgA+DhEBAAA/EBIBAAArExQBAAAxExUBAAAhExQBAAEaJBgBAAEqIw8BAAIkCRYBAANBJRUBAANECR8BAAQiKScBAAQzNQkBAAQ6JicBAAUPMQkCBwQFFDM0AgcEBSAzDwEHBTU3LwIHBAYdGAkBAwcYHAkAByciFAEIBywbHAAHQBEUAAgjGg8BAAsXLQ8BAwseCRcBAwsoMgkBAwspFysBAws4LBUBAyMWIRgcHRQeHiERFRAVEx4XHhUeJRYmFiIWCS4YMBIvJBYZMBYeGjYbMAMICQMICQELAAEJAAIGCAsHCA0CCwEBCQALAgEJAAQHCwEBCQAGCwIBCQALBQEDBwgNAQsIAQgMAwsBAQkACwIBCQAHCA0CBgsBAQkACwABCQAECQEHCwEBCQAGCwIBCQAJAgACCQEGCwEBCQABBgkCAwkBBwsBAQkACwgBCAwCCQEHCwABCQABBgsBAQkAAQECBwsBAQkABgsCAQkAAQYICgEHCAoBBgsAAQkAAQgJAQMBCAYBCw4BCQABCQAFCAoLDgEIBgsHAQgMCAoICQEGCAsBBwgNAQgKAQsDAQkAAQgMAQsHAQkAAwMDAwELAQEJAAEGCQABBgsFAQkAAQsFAQkAAQYLBwEJAAMHCwcBCQADBwgNAQsIAQkAAgsHAQgMCAoCCwcBCQAHCA0HCggGCAkICQMLDgEIBggGAwEKCQABBgsOAQkAAgYLDgEJAAYJAAIJAAkBAQkBAgsEAQkBCQIDBwgKCQAJAQIHCw4BCQAJAAIGCAoJAAEGCQECBwsHAQkACwgBCQABCwQBCQECBwgKCQAHQmFsYW5jZQRDb2luAklEBk9wdGlvbglQdWJsaXNoZXIHUnVsZUtleQNTVUkOVHJhbnNmZXJQb2xpY3kRVHJhbnNmZXJQb2xpY3lDYXAVVHJhbnNmZXJQb2xpY3lDcmVhdGVkD1RyYW5zZmVyUmVxdWVzdAlUeENvbnRleHQIVHlwZU5hbWUDVUlEBlZlY1NldANhZGQLYWRkX3JlY2VpcHQIYWRkX3J1bGUOYWRkX3RvX2JhbGFuY2UHYmFsYW5jZQZib3Jyb3cEY29pbg9jb25maXJtX3JlcXVlc3QIY29udGFpbnMGZGVsZXRlFGRlc3Ryb3lfYW5kX3dpdGhkcmF3DGRlc3Ryb3lfc29tZQtkdW1teV9maWVsZA1keW5hbWljX2ZpZWxkBGVtaXQFZW1wdHkFZXZlbnQHZXhpc3RzXwRmcm9tDGZyb21fYmFsYW5jZQxmcm9tX3BhY2thZ2UDZ2V0CGdldF9ydWxlCGhhc19ydWxlAmlkBmluc2VydAlpbnRvX2tleXMHaXNfc29tZQRpdGVtA25ldwtuZXdfcmVxdWVzdAZvYmplY3QGb3B0aW9uB3BhY2thZ2UEcGFpZAlwb2xpY3lfaWQDcHV0CHJlY2VpcHRzBnJlbW92ZQtyZW1vdmVfcnVsZQVydWxlcwRzaXplA3N1aQR0YWtlD3RyYW5zZmVyX3BvbGljeQp0eF9jb250ZXh0CXR5cGVfbmFtZQN1aWQQdWlkX211dF9hc19vd25lcgx1aWRfdG9faW5uZXIFdmFsdWUHdmVjX3NldAh3aXRoZHJhdwR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAACBCsICTEDIQgJNAsOAQgGAQIDJwgKEwsHAQgMNwsOAQgGAgICJwgKMggJAwIBJwgJBAIBGwEAGAMYARgCGAQvAAEAAAkGCwALAQsCOAA5AAIBAQAAGSALADgBBAQFCAsBAQYAAAAAAAAAACcKAREfDAUOBREgDAYKBjkBOAILBQwCOAAMAzgDDAQLAgsECwM5AgsBER8LBjkDAgIBAAAgMQoALjgECwE3ABQhBAkFDwsAAQsDAQcEJw4COAUEJQsCOAYMBgoGCgA3ATgHJQQcBSILAAELAwEHBScLBgwEBSkKADcBOAcMBAsEDAULADYBCwULAzgIAgMBAAAoGw4AOAQOATcAFCEECAUMCwIBBwQnCwE6AwEMBAsAOgIBDAMRHQsEER0LAwsCOAkCBAEAACo0CwE6AAwGDAMMBQwECwY4CgwCDgJBFgwICggKADcCOAshBBMFFwsAAQcAJwoIBgAAAAAAAAAAJAQuBRwNAkUWDAcKADcCDgc4DAQlBSkLAAEHAScLCAYBAAAAAAAAABcMCAUXCwABCwQLBQsDAgUBAAAJIgoBLjgECwI3ABQhBAkFDQsBAQcEJwoBLjgNIAQTBRcLAQEHAycKATYDCTkECwM4DgsBNgI4DzgQAgYBAAAJBgsBNwMJOQQ4EQIHAQAACQ4KAS44DQQFBQkLAQEHAicLATYBCwI4EgIIAQAACQULATYEOA84EAIJAQAACQYLADcDCTkEOBMCCgEAAAkUCgAuOAQLATcAFCEECQUNCwABBwQnCwA2Awk5BDgUAQILAQAACQMLADcDAgwBAAAJEAoALjgECwE3ABQhBAkFDQsAAQcEJwsANgMCDQEAAAkECwA3BRQCDgEAAAkECwA3BhQCDwEAAAkECwA3BxQCAgEBAQECAQAAAwAAAAEAAgAYARgCGAMYBBgFGAYYBxgAFGR5bmFtaWNfb2JqZWN0X2ZpZWxk2QehHOsLBgAAAAoBAAgCCBQDHIoBBKYBGgXAAYMBB8MCsgII9QRACrUFBgu7BQIMvQXpAQALARYACgAVAAMHAQAAAQEHAQAAAwAHAAMCBAAABAABAgcMAAYCAwIHDAAJBAUCBwwAFwQGAgcMAAwCBwEHAA0CBwIHDAARAggBBwEUARgBAAEZChgBAAIEAAECBwQCBRIBAQgCBw8LAQgCCBMUAQgCDQIHAgcEAg4CDwEHAg8EEwEHAhAWBwEIAhcEBgIHBAIYFgoBCAMRCwwBCAMSEQwAAxoQEQATBgkNDg4KBgsGDw4MBhIGEQ0NDRAGBwwIDAMHCAMJAAkBAAIGCAMJAAEGCQECBwgDCQABBwkBAQkBAQEBCwEBCAIDCwABCQAIAgsAAQkAAQkAAQYJAAEIAgILAAEJAAgCAQsAAQkAAgYIAwUBBggDAQUCBQkAAgcIAwUBBwkABAsAAQkACwABCQAJAQUCBQUCCwABCQAFAQsBAQkAAklEBk9wdGlvbgNVSUQHV3JhcHBlcgNhZGQQYWRkX2NoaWxkX29iamVjdAZib3Jyb3cTYm9ycm93X2NoaWxkX29iamVjdBdib3Jyb3dfY2hpbGRfb2JqZWN0X211dApib3Jyb3dfbXV0DWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlCmZpZWxkX2luZm8OZmllbGRfaW5mb19tdXQYaGFzX2NoaWxkX29iamVjdF93aXRoX3R5AmlkD2lkX2Zyb21fYWRkcmVzcwRuYW1lBG5vbmUGb2JqZWN0Bm9wdGlvbgZyZW1vdmUTcmVtb3ZlX2NoaWxkX29iamVjdARzb21lDnVpZF90b19hZGRyZXNzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQACARMJAAAKAAEAAAkVCwE5AAwFDgI4AAwECgAKBQsEOAELAAsFDAMuCwM4AgERFQsCOAMCAQEAAA4ICwE5AAwCCwALAjgCOAQCAgEAAA4ICwE5AAwCCwALAjgFOAYCAwEAABUUCwE5AAwDCgAKAwwCLgsCOAIMBREVCwU4BwwECwALAzgIAQsEAgQBAAAOBwsBOQAMAgsACwI4CQIFAQAAFxQLATkADAIKAAoCOAkgBAwLAAEJAgsACwI4AgwDERULAzgKAgYBAAAXFQsBOQAMAgoACgI4CSAEDAsAATgLAgsACwI4AgwDAQsDERQ4DAIANwp0eF9jb250ZXh0CVR4Q29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdAJJRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdANVSUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDYmFnA0JhZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2JhbGFuY2UGU3VwcGx5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHYmFsYW5jZQdCYWxhbmNlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDYmNzA0JDUwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBmJvcnJvdwhSZWZlcmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBmJvcnJvdwZCb3Jyb3cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVjbG9jawVDbG9jawAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3VybANVcmwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luBENvaW4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luDENvaW5NZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBGNvaW4LVHJlYXN1cnlDYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luD0N1cnJlbmN5Q3JlYXRlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3ZlY19tYXAGVmVjTWFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHdmVjX21hcAVFbnRyeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3BhY2thZ2UJUHVibGlzaGVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQpVcGdyYWRlQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQ1VcGdyYWRlVGlja2V0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQ5VcGdyYWRlUmVjZWlwdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2Rpc3BsYXkHRGlzcGxheQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2Rpc3BsYXkORGlzcGxheUNyZWF0ZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdkaXNwbGF5DlZlcnNpb25VcGRhdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIUZHluYW1pY19vYmplY3RfZmllbGQHV3JhcHBlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2dyb3RoMTYFQ3VydmUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdncm90aDE2FFByZXBhcmVkVmVyaWZ5aW5nS2V5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHZ3JvdGgxNhFQdWJsaWNQcm9vZklucHV0cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2dyb3RoMTYLUHJvb2ZQb2ludHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgd2ZWNfc2V0BlZlY1NldAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3N1aQNTVUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg90cmFuc2Zlcl9wb2xpY3kPVHJhbnNmZXJSZXF1ZXN0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5DlRyYW5zZmVyUG9saWN5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5EVRyYW5zZmVyUG9saWN5Q2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5FVRyYW5zZmVyUG9saWN5Q3JlYXRlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD3RyYW5zZmVyX3BvbGljeQdSdWxlS2V5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sFS2lvc2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zaw1LaW9za093bmVyQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sLUHVyY2hhc2VDYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawZCb3Jyb3cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawRJdGVtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sHTGlzdGluZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBWtpb3NrBExvY2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawpJdGVtTGlzdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMbGlua2VkX3RhYmxlC0xpbmtlZFRhYmxlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMbGlua2VkX3RhYmxlBE5vZGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgpvYmplY3RfYmFnCU9iamVjdEJhZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDG9iamVjdF90YWJsZQtPYmplY3RUYWJsZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDnByaW9yaXR5X3F1ZXVlDVByaW9yaXR5UXVldWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg5wcmlvcml0eV9xdWV1ZQVFbnRyeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBXRhYmxlBVRhYmxlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJdGFibGVfdmVjCFRhYmxlVmVjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJdmVyc2lvbmVkCVZlcnNpb25lZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCXZlcnNpb25lZBBWZXJzaW9uQ2hhbmdlQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAAAAAAAAAyA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAQAAAAAAAAALB2dlbmVzaXOAE6Ec6wsGAAAACwEAGgIaOgNUawS/AQ4FzQGwAgf9A4kJCIYNYAbmDRQK+g1dDNcO2wMNshIYAB8BLAFIAhICFAIrAj0CQgA2AD8AQABDAEYAAwMAAAIDAAAJAAAACAAAAQQHAQAAAwAEAQABBAEMAQABBQsEAAYFAgAHCgIACAYEAAoHBAALDAQAABYAAQAADwIBAAAOAwEAARkZGgEAASQYDgEAAiMWDgEAAxoJAQEAAzUICQEAA0sBCQEABB0eHwEABkEgAQAHGwUGAAgWERIACRYTAQAKFw8QAAsNIgEACyoMCgALNB0BAAwgGxwADCINDgAHBwgHBRUEFwMXCQcGBwYIBwsFAQgICAEKCAAIAgcICQAECwUBCAgKCAMHCggMBwgJAQcKCAwZCggDAwMKAgMDCgIKAgoCCgIKAgoCCgIKAgoCCAoDCwUBCAgLBQEICAUICwgMCggMCgIKAgEGCAkBAwEICAIHCwUBCQADAQsFAQkAAQgMAQgAEAUKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIDAwcICQIGCggMBggMAQEIAwMDAwMDAwcICQEICwULBQEICAMDDQcICQEICggIBwoIDAsFAQgIAwMICwgKBwgJBQsFAQgIAwULBAEFBQEIAwEGCgkAAQUBBgsEAQkAAQsEAQkAAQkAAgcKCAwFAQcIDAQHCAwLBQEICAUHCAkCCwUBCQAHCAkBCwYBCQACCwYBCAgFAgMDAgcIDAMHQmFsYW5jZQRDb2luFkdlbmVzaXNDaGFpblBhcmFtZXRlcnMYR2VuZXNpc1ZhbGlkYXRvck1ldGFkYXRhBk9wdGlvbgNTVUkMU3Rha2VTdWJzaWR5EFN5c3RlbVBhcmFtZXRlcnMPVG9rZW5BbGxvY2F0aW9uGVRva2VuRGlzdHJpYnV0aW9uU2NoZWR1bGUJVHhDb250ZXh0A1VJRAlWYWxpZGF0b3IIYWN0aXZhdGUTYWN0aXZhdGVfdmFsaWRhdG9ycw9hbGxvY2F0ZV90b2tlbnMLYWxsb2NhdGlvbnMLYW1vdW50X21pc3QHYmFsYW5jZRhjaGFpbl9zdGFydF90aW1lc3RhbXBfbXMEY29pbg9jb21taXNzaW9uX3JhdGUGY3JlYXRlGGNyZWF0ZV9zeXN0ZW1fcGFyYW1ldGVycwtkZXNjcmlwdGlvbgxkZXN0cm95X3NvbWUMZGVzdHJveV96ZXJvBWVwb2NoEWVwb2NoX2R1cmF0aW9uX21zDGZyb21fYmFsYW5jZQlnYXNfcHJpY2UHZ2VuZXNpcxFnZXRfdmFsaWRhdG9yX211dAlpbWFnZV91cmwWaXNfZHVwbGljYXRlX3ZhbGlkYXRvcghpc19lbXB0eQdpc19zb21lE21heF92YWxpZGF0b3JfY291bnQbbWluX3ZhbGlkYXRvcl9qb2luaW5nX3N0YWtlBG5hbWUPbmV0d29ya19hZGRyZXNzEm5ldHdvcmtfcHVibGljX2tleQNuZXcGb2JqZWN0Bm9wdGlvbgtwMnBfYWRkcmVzcw9wcmltYXJ5X2FkZHJlc3MLcHJvamVjdF91cmwTcHJvb2Zfb2ZfcG9zc2Vzc2lvbhNwcm90b2NvbF9wdWJsaWNfa2V5EHByb3RvY29sX3ZlcnNpb24RcmVjaXBpZW50X2FkZHJlc3MccmVxdWVzdF9hZGRfc3Rha2VfYXRfZ2VuZXNpcwVzcGxpdA1zdGFrZV9zdWJzaWR5G3N0YWtlX3N1YnNpZHlfZGVjcmVhc2VfcmF0ZRdzdGFrZV9zdWJzaWR5X2Z1bmRfbWlzdClzdGFrZV9zdWJzaWR5X2luaXRpYWxfZGlzdHJpYnV0aW9uX2Ftb3VudBtzdGFrZV9zdWJzaWR5X3BlcmlvZF9sZW5ndGgZc3Rha2Vfc3Vic2lkeV9zdGFydF9lcG9jaBVzdGFrZWRfd2l0aF92YWxpZGF0b3IDc3VpC3N1aV9hZGRyZXNzCnN1aV9zeXN0ZW0Wc3VpX3N5c3RlbV9zdGF0ZV9pbm5lcgh0cmFuc2Zlcgp0eF9jb250ZXh0CXZhbGlkYXRvciB2YWxpZGF0b3JfbG93X3N0YWtlX2dyYWNlX3BlcmlvZB12YWxpZGF0b3JfbG93X3N0YWtlX3RocmVzaG9sZA12YWxpZGF0b3Jfc2V0InZhbGlkYXRvcl92ZXJ5X2xvd19zdGFrZV90aHJlc2hvbGQGdmVjdG9yDndvcmtlcl9hZGRyZXNzEXdvcmtlcl9wdWJsaWNfa2V5BHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAACDycKAhgKAiEKAi8KAj4FHgMVAzEKAjAKAikKAkoKAigKAi0KAi4KAkkKAgECDDIDEwMcAzsDOQM6AzcNJQMmA0UDRwNEAwICAjgDEAoIAwMCAzMFEQM8CwQBBQAAAAAEkwEKBS4RCwYAAAAAAAAAACEEBwULCwUBBwAnCwQTAgwGDBYNAQsWOAAMGDgBDBdACgAAAAAAAAAADBwOA0ELDAgGAAAAAAAAAAAMCwoLCggjBFkFIQ4DCgtCCxQTAAwdDBEMEAwODB4MDwwTDBQMBwwKDBkMEgwMDAkMDQsZCxQLDwseCxMLDQsJCwwLEgsOCxALEQsdCwoLBwoFERAMGw4cDhsREyAETQVRCwUBBwEnDRwLG0QKCwsGAQAAAAAAAAAWDAsFHAsBCwYNHAoFEQENHBECDgIQABQOAhABFA4CEAIUDgIQAxQOAhAEFA4CEAUUDgIQBhQKBREODBoLGA4CEAcUDgIQCBQOAhAJFAoFEQwMFQsACxwLFw4CEAoUDgIQCxQLGgsVCwURDQIBAAAAFCwOATgCIAQjBQUNAUUVEwMMBwwFDAYNAAsFOAAMBA4HOAMEHQsHOAQMCAoCCwgREgsECwYKAxERBSILBAoDOAULBhEKBQALAgELAwELAUYVAAAAAAAAAAALADgGAgIAAAAhGAoALkEKDAEGAAAAAAAAAAAMAgoCCgEjBBUFCwoACgJDCgYAAAAAAAAAABEPCwIGAQAAAAAAAAAWDAIFBgsAAQIBAgEDAQcBCAEJAQoBCwEEAQUBBgEAAQEACXZhbGlkYXRvctI8oRzrCwYAAAAMAQAfAh9IA2e3BASeBSYFxAXwAwe0CckTCP0cYAbdHaoBCocfnAEMoyCpGw3MOzwPiDwNAIYBARQBFwFJAWcCFQIWAiICRwJoAm8CgwEAZQCIAQAOBAAADQQAAAgDAAALAwABCQcAAwMHAQAABAkHAAUADAAGAQQBAAEIAgcACQUCAAoKAgALDAcADAQHAAwGCAAMBwwADQ8CAAA3AAEAADUCAwAAGgQFAAAQBAUAABIGBQAAVgcFAABXBwUAAFoIBQAAWQkFAABeCQUAAFgEBQAAXQQFAAAdCgUAAFILBQAALgwNAAAwDA4AAGkMDwAAMQwQAAAeDBAAACkMEQAAUwwRAAAzDBAAAEoMEAAATwwQAACOAQwQAABVDBIAAFQMEgAANAwSAACPAQwSAAA9DBMAAD8MEwAAQAwTAABEDBMAAEIMFAAAQQwUAAA+DBQAAEUMFAAASAwVAAA7DBYAAG4MFgAAYgwWAABtDBYAAI0BDBYAAF8EBQAASwwWAABMDBYAACYMFgAAGQwWAABOFxgAAGYMGQAAKhoNAAAsGw0BAAArHA0BAAA5CwUAAHodBQAAeB0FAAB5HQUAAIIBHQUAAHsdBQAAcR0FAAB9HQUAAHMdBQAAfh0FAAB0HQUAAIABHQUAAHYdBQAAfx4FAAB1HgUAAHwdBQAAch0FAACBAR0FAAB3HQUAAB8GBQAAhAEOBQAAhQEfBQAANiADAAFnHyYAAmw+HwEAAxhAPgEAAyRDMwEAAy1ADQEAAy9ADQEAA0YFIgEAA2AzIgEABCUmIwAFNSgpAAaLAS0WAQAHIDMFAQMIKD4ZAQgKIS4WAApcLg8ACzgfJwAMESoFAAwbKgUADBw6BQAMLjANAAw1KD0ADEswFgAMTDAWAAxOPBgADFExBQAMUjsFAAxWLwUADFo2FgAMYTUWAAxjNRYADGowFgANOUIZAA2MATg5AFIfUiNWLFcyVzdYPTQjNB8zIzMfUDNOM1MjUx9RI08jUR9PH00BDgUKAgoCCgIKAggGCAYIDAgMCAYIBggGCAYIBwEIABAFCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCAwMHCAsBCAECBwgBAwABBwgBBAcIAQsIAQgKBQcICwMHCAEIDgcICwMHCAEIEAMCBwgBCwgBCAoCBwgBBwgLAQYIAQEBAQYIAAEFAQYIBgEGCAwBBgoCAQYLBQEIBgEGCwUBCgIBBggJAQMCBggBAwEIDQEICQIGCAEGCAECBgsFAQkABgkAAgYLBQEJAAYLBQEJAAIHCAEKAgMHCAEKAgoCAQoCBAgAAwMHCAsWBQgGCAYIBggGCwUBCgILBQEKAgsFAQoCCwUBCgILBQEIBgsFAQgGCgILBQEIBgsFAQgGCAcKAgoCCgIIBggGCAwIDAELBQEJAAEIBggBAQEBAQEBCAABAgEIBAEIDAEHCAsBCAcCBwgPAwIDAwEICgEGCwgBCQABBggLBQcIDwsIAQgKBQMHCAsBBggPAQcIDwEIAgEJAAQDAwMDAQYIDgMHCA8IDgcICwEIAwEGCBABBgUCBwgPCwgBCAoCBwgPBwgLAgYIDwMBCA8BBgkAHQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQYLBQEJAAIBAQIFBwgLAQcLBQEJAAMICQgPBQNCYWcHQmFsYW5jZQJJRAZPcHRpb24VUG9vbFRva2VuRXhjaGFuZ2VSYXRlA1NVSQlTdGFrZWRTdWkLU3Rha2luZ1Bvb2wTU3Rha2luZ1JlcXVlc3RFdmVudAZTdHJpbmcJVHhDb250ZXh0FVVuc3Rha2luZ1JlcXVlc3RFdmVudANVcmwJVmFsaWRhdG9yEVZhbGlkYXRvck1ldGFkYXRhFVZhbGlkYXRvck9wZXJhdGlvbkNhcAhhY3RpdmF0ZRVhY3RpdmF0ZV9zdGFraW5nX3Bvb2waYWRqdXN0X3N0YWtlX2FuZF9nYXNfcHJpY2UGYW1vdW50BWFzY2lpA2JhZwdiYWxhbmNlA2JjcwZib3Jyb3cPY29tbWlzc2lvbl9yYXRlCmRlYWN0aXZhdGUXZGVhY3RpdmF0ZV9zdGFraW5nX3Bvb2wPZGVwb3NpdF9yZXdhcmRzFWRlcG9zaXRfc3Rha2VfcmV3YXJkcwtkZXNjcmlwdGlvbhplZmZlY3R1YXRlX3N0YWdlZF9tZXRhZGF0YQRlbWl0BWVwb2NoBWV2ZW50DGV4dHJhX2ZpZWxkcwdleHRyYWN0CmZyb21fYXNjaWkJZ2FzX3ByaWNlB2dlbmVzaXMCaWQJaW1hZ2VfdXJsDGlzX2R1cGxpY2F0ZQ1pc19lcXVhbF9zb21lF2lzX2VxdWFsX3NvbWVfYW5kX3ZhbHVlB2lzX25vbmUMaXNfcHJlYWN0aXZlB2lzX3NvbWUIbWV0YWRhdGEEbmFtZQtuZXRfYWRkcmVzcw9uZXR3b3JrX2FkZHJlc3MUbmV0d29ya19wdWJrZXlfYnl0ZXMDbmV3EW5ld19mcm9tX21ldGFkYXRhDG5ld19tZXRhZGF0YRVuZXdfdW5zYWZlX2Zyb21fYnl0ZXMzbmV3X3VudmVyaWZpZWRfdmFsaWRhdG9yX29wZXJhdGlvbl9jYXBfYW5kX3RyYW5zZmVyGm5leHRfZXBvY2hfY29tbWlzc2lvbl9yYXRlFG5leHRfZXBvY2hfZ2FzX3ByaWNlFm5leHRfZXBvY2hfbmV0X2FkZHJlc3MabmV4dF9lcG9jaF9uZXR3b3JrX2FkZHJlc3MfbmV4dF9lcG9jaF9uZXR3b3JrX3B1YmtleV9ieXRlcxZuZXh0X2Vwb2NoX3AycF9hZGRyZXNzGm5leHRfZXBvY2hfcHJpbWFyeV9hZGRyZXNzHm5leHRfZXBvY2hfcHJvb2Zfb2ZfcG9zc2Vzc2lvbiBuZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleV9ieXRlcxBuZXh0X2Vwb2NoX3N0YWtlGW5leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MebmV4dF9lcG9jaF93b3JrZXJfcHVia2V5X2J5dGVzBG5vbmUGb2JqZWN0EG9wZXJhdGlvbl9jYXBfaWQGb3B0aW9uC3AycF9hZGRyZXNzFHBlbmRpbmdfc3Rha2VfYW1vdW50HXBlbmRpbmdfc3Rha2Vfd2l0aGRyYXdfYW1vdW50B3Bvb2xfaWQhcG9vbF90b2tlbl9leGNoYW5nZV9yYXRlX2F0X2Vwb2NoD3ByaW1hcnlfYWRkcmVzcxBwcmluY2lwYWxfYW1vdW50FXByb2Nlc3NfcGVuZGluZ19zdGFrZSRwcm9jZXNzX3BlbmRpbmdfc3Rha2VzX2FuZF93aXRoZHJhd3MLcHJvamVjdF91cmwTcHJvb2Zfb2ZfcG9zc2Vzc2lvbhVwcm90b2NvbF9wdWJrZXlfYnl0ZXMRcmVxdWVzdF9hZGRfc3Rha2UccmVxdWVzdF9hZGRfc3Rha2VfYXRfZ2VuZXNpcxtyZXF1ZXN0X3NldF9jb21taXNzaW9uX3JhdGUVcmVxdWVzdF9zZXRfZ2FzX3ByaWNlFnJlcXVlc3Rfd2l0aGRyYXdfc3Rha2UNcmV3YXJkX2Ftb3VudAZzZW5kZXIdc2V0X2NhbmRpZGF0ZV9jb21taXNzaW9uX3JhdGUXc2V0X2NhbmRpZGF0ZV9nYXNfcHJpY2UQc2V0X3ZvdGluZ19wb3dlcgRzb21lFnN0YWtlX2FjdGl2YXRpb25fZXBvY2gMc3Rha2VfYW1vdW50EXN0YWtlZF9zdWlfYW1vdW50DnN0YWtlcl9hZGRyZXNzDHN0YWtpbmdfcG9vbA9zdGFraW5nX3Bvb2xfaWQGc3RyaW5nA3N1aQtzdWlfYWRkcmVzcwtzdWlfYmFsYW5jZRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyCHRvX2J5dGVzC3RvdGFsX3N0YWtlEnRvdGFsX3N0YWtlX2Ftb3VudAp0eF9jb250ZXh0D3Vuc3Rha2luZ19lcG9jaCB1cGRhdGVfY2FuZGlkYXRlX25ldHdvcmtfYWRkcmVzcx91cGRhdGVfY2FuZGlkYXRlX25ldHdvcmtfcHVia2V5HHVwZGF0ZV9jYW5kaWRhdGVfcDJwX2FkZHJlc3MgdXBkYXRlX2NhbmRpZGF0ZV9wcmltYXJ5X2FkZHJlc3MgdXBkYXRlX2NhbmRpZGF0ZV9wcm90b2NvbF9wdWJrZXkfdXBkYXRlX2NhbmRpZGF0ZV93b3JrZXJfYWRkcmVzcx51cGRhdGVfY2FuZGlkYXRlX3dvcmtlcl9wdWJrZXkSdXBkYXRlX2Rlc2NyaXB0aW9uEHVwZGF0ZV9pbWFnZV91cmwLdXBkYXRlX25hbWUhdXBkYXRlX25leHRfZXBvY2hfbmV0d29ya19hZGRyZXNzIHVwZGF0ZV9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5HXVwZGF0ZV9uZXh0X2Vwb2NoX3AycF9hZGRyZXNzIXVwZGF0ZV9uZXh0X2Vwb2NoX3ByaW1hcnlfYWRkcmVzcyF1cGRhdGVfbmV4dF9lcG9jaF9wcm90b2NvbF9wdWJrZXkgdXBkYXRlX25leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MfdXBkYXRlX25leHRfZXBvY2hfd29ya2VyX3B1YmtleRJ1cGRhdGVfcHJvamVjdF91cmwDdXJsEXZhbGlkYXRlX21ldGFkYXRhFXZhbGlkYXRlX21ldGFkYXRhX2Jjcwl2YWxpZGF0b3IRdmFsaWRhdG9yX2FkZHJlc3MNdmFsaWRhdG9yX2NhcA12YWxpZGF0b3Jfc2V0EXZhbGlkYXRvcl93cmFwcGVyBXZhbHVlHnZlcmlmaWVkX29wZXJhdGlvbl9jYXBfYWRkcmVzcwx2b3RpbmdfcG93ZXIOd29ya2VyX2FkZHJlc3MTd29ya2VyX3B1YmtleV9ieXRlcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAMIBgAAAAAAAAADCAcAAAAAAAAAAwgIAAAAAAAAAAMICQAAAAAAAAADCAoAAAAAAAAAAwgLAAAAAAAAAAMIDAAAAAAAAAADCGQAAAAAAAAAAwhlAAAAAAAAAAMIECcAAAAAAAADCAABAAAAAAAAAAIWaQVVCgI0CgKPAQoCVAoCMQgGHggGKQgMUwgMMggGSggGTwgGjgEIBkILBQEKAkELBQEKAj4LBQEKAkULBQEKAjwLBQEIBj8LBQEIBkALBQEIBkQLBQEIBiMIBwECCjAIAI0BA0gICSYDZQgPGQNDAzsDOgMjCAcCAgVNCAmHAQVkBSEDEwMDAgdNCAmHAQVkBWEDcANQA1sDAAMAACFECwAMDgsBDBkLAgwdCwMMHgsEDB8LBQwgCwYMIQsHDCILCAwjCwkMDwsKDBALCwwRCwwMEjgADBM4AAwUOAAMFTgADBY4AQwXOAEMGDgBDBo4AQwbCw0MHAsOCxkLHQseCx8LIAshCyILIwsPCxALEQsSCxMLFgsUCxULFwsYCxoLGwscEgACAQMAACSAAQ4JQSUHECUECw4KQSUHECUMEAUNCQwQCxAEFQ4LQSUHECUMEQUXCQwRCxEEHw4MQSUHECUMEgUhCQwSCxIEKQ4FQSUHECUMEwUrCQwTCxMEMw4GQSUHECUMFAU1CQwUCxQEPQ4HQSUHECUMFQU/CQwVCxUERw4IQSUHECUMFgVJCQwWCxYETAVQCw8BBwknCg4HDyUEVQVZCw8BBwgnCwALAQsCCwMLBAsFEUwRVAsGEUwRVAsHEVsLCBFbCwkRTBFUCwoRTBFUCwsRTBFUCwwRTBFUCg8RVREADBcOFxFJCxcLDQsOCw8RSwICAwAABQULAA8ACwERXQIDAwAABQULAA8ACwERXAIEAwAABQ0KABABFAoADwIVCgAQAxQLAA8EFQIFAwAAKzkOATgCDAQKBAYAAAAAAAAAACQECAUOCwABCwMBBwsnCgMuEVkGAQAAAAAAAAAWDAUKAA8ACwEKAgsFCgMRZgoAEAARXwQiCgAPABFkCgAQBRQKBBYKAA8FFQoALhExCwAQBhAHFAsCCwMuEVkLBBICOAMCBgMAABYuCgMuEVkGAAAAAAAAAAAhBAcFDQsAAQsDAQcMJw4BOAIMBAoEBgAAAAAAAAAAJAQVBRsLAAELAwEHCycKAA8ACwELAgYAAAAAAAAAAAsDEWYKAA8AEWQKABAFFAsEFgsADwUVAgcDAAA0Kw4BEWkMAw4BEWgMBQoADwALAQoCEWcMBgoGCgMXDAQKABAFFAsGFwoADwUVCgAuETELABAGEAcUCgIuEVoLBQsCLhFZCwMLBBIDOAQCCAMAAAUTDgERbBQKABAGEAcUIQQKBQ4LAAEHDicLAgsADwEVAgkDAAAFIAoALhEOBAUFCQsAAQcKJw4BEWwUCgAQBhAHFCEEEwUXCwABBw4nCgIKAA8BFQsCCwAPAhUCCgMAAAUOCgEHDyUEBQUJCwABBwgnCwELAA8DFQILAwAABRcKAC4RDgQFBQkLAAEHCicKAQcPJQQOBRILAAEHCCcLAQsADwQVAgwDAAAFDgoAEAUUDgE4AhYKAA8FFQsADwALARFeAg0DAAAFEAoADwALARFlCgAuESgLABAFFCEEDQUPBwsnAg4BAAAFBAsAEAARXwIPAQAABQMLABAGAhABAAAFBQsAEAYQBxQCEQEAAAUECwAQBhAIAhIBAAAFBAsAEAYQCQITAQAABQQLABAGEAoCFAEAAAUECwAQBhALAhUBAAAFBAsAEAYQDAIWAQAABQQLABAGEA0CFwEAAAUECwAQBhAOAhgBAAAFBAsAEAYQDwIZAQAABQQLABAGEBACGgEAAAUECwAQBhARAhsBAAAFBAsAEAYQEgIcAQAABQQLABAGEBMCHQEAAAUECwAQBhAUAh4BAAAFBAsAEAYQFQIfAQAABQQLABAGEBYCIAEAAAUECwAQBhAXAiEBAAAFBAsAEAYQGAIiAQAABQQLABAGEBkCIwEAAAUECwAQBhAaAiQBAAAFBAsAEAYQGwIlAQAABQMLABAcAiYBAAAFBAsAEAEUAicBAAAFBSgLABAAEWoCKAEAAAUECwAQABFqAikBAAAFAwsAESgCKgEAAAUECwAQHRQCKwMAAAUFCwELAA8dFQIsAQAABQQLABAAEWECLQEAAAUECwAQABFiAi4BAAAFBAsAEAIUAi8BAAAFBAsAEAQUAjABAAAFBQsAEAALARFjAjEBAAAFBAsAEAA4BQIyAQAAP5cDCgAQBhAHFAoBEAYQBxQhBA0IDAIFFwoAEAYQCBQKARAGEAgUIQwCCwIEHAgMDQUmCgAQBhAMFAoBEAYQDBQhDA0LDQQrCAwYBTUKABAGEA0UCgEQBhANFCEMGAsYBDoIDBkFRAoAEAYQEBQKARAGEBAUIQwZCxkESQgMGgVTCgAQBhASFAoBEAYQEhQhDBoLGgRYCAwbBWIKABAGEBIUCgEQBhATFCEMGwsbBGcIDBwFcQoAEAYQExQKARAGEBMUIQwcCxwEdggMHQWAAQoAEAYQExQKARAGEBIUIQwdCx0EhQEIDB4FjQEKABAGEBQKARAGEBQ4BgweCx4EkgEIDAMFmgEKABAGEBUKARAGEBU4BgwDCwMEnwEIDAQFpwEKABAGEBgKARAGEBg4BwwECwQErAEIDAUFtAEKABAGEBoKARAGEBo4BwwFCwUEuQEIDAYFwQEKABAGEBoKARAGEBs4BwwGCwYExgEIDAcFzgEKABAGEBsKARAGEBs4BwwHCwcE0wEIDAgF2wEKABAGEBsKARAGEBo4BwwICwgE4AEIDAkF6AEKABAGEBQKARAGEAw4CAwJCwkE7QEIDAoF9QEKABAGEBUKARAGEA04CAwKCwoE+gEIDAsFggIKABAGEBgKARAGEBA4CQwLCwsEhwIIDAwFjwIKABAGEBoKARAGEBI4CQwMCwwElAIIDA4FnAIKABAGEBoKARAGEBM4CQwOCw4EoQIIDA8FqQIKABAGEBsKARAGEBM4CQwPCw8ErgIIDBAFtgIKABAGEBsKARAGEBI4CQwQCxAEuwIIDBEFwwIKARAGEBQKABAGEAw4CAwRCxEEyAIIDBIF0AIKARAGEBUKABAGEA04CAwSCxIE1QIIDBMF3QIKARAGEBgKABAGEBA4CQwTCxME4gIIDBQF6gIKARAGEBoKABAGEBI4CQwUCxQE7wIIDBUF9wIKARAGEBoKABAGEBM4CQwVCxUE/AIIDBYFhAMKARAGEBsKABAGEBM4CQwWCxYEjQMLAAELAQEIDBcFlQMLARAGEBsLABAGEBI4CQwXCxcCMwAAAA0RCgA4CgQKCwEBCwABCQwCBQ8LADgLCwEhDAILAgI0AAAAQRoKADgKBAYIDAIFCQoBOAoMAgsCBBILAQELAAEJDAMFGAsAOAsLATgLIQwDCwMCNQMAAA8ZCgEuEVoMAgoCCgAQBhAHFCEEDAUSCwABCwEBBw0nCwILARFrCwAPHBUCNgMAAAUSDgFBJQcQJQQGBQoLAAEHCScLARFMEVQLAA8GDwgVAjcDAAAFEg4BQSUHECUEBgUKCwABBwknCwERTBFUCwAPBg8JFQI4AwAABREOAUElBxAlBAYFCgsAAQcJJwsBEVsLAA8GDwoVAjkDAAAFEQ4BQSUHECUEBgUKCwABBwknCwERWwsADwYPCxUCOgMAAAUWDgFBJQcQJQQGBQoLAAEHCScLARFMEVQ4DAoADwYPFBULABAGEUkCOwMAAAUeCgAuEQ4EBQUJCwABBwonDgFBJQcQJQQPBRMLAAEHCScLARFMEVQKAA8GDwwVCwAQBhFJAjwDAAAFFg4BQSUHECUEBgUKCwABBwknCwERTBFUOAwKAA8GDxUVCwAQBhFJAj0DAAAFHgoALhEOBAUFCQsAAQcKJw4BQSUHECUEDwUTCwABBwknCwERTBFUCgAPBg8NFQsAEAYRSQI+AwAABRYOAUElBxAlBAYFCgsAAQcJJwsBEUwRVDgMCgAPBg8WFQsAEAYRSQI/AwAABR4KAC4RDgQFBQkLAAEHCicOAUElBxAlBA8FEwsAAQcJJwsBEUwRVAoADwYPDhULABAGEUkCQAMAAAUWDgFBJQcQJQQGBQoLAAEHCScLARFMEVQ4DAoADwYPFxULABAGEUkCQQMAAAUeCgAuEQ4EBQUJCwABBwonDgFBJQcQJQQPBRMLAAEHCScLARFMEVQKAA8GDw8VCwAQBhFJAkIDAAAFEAsBOA0KAA8GDxgVCwI4DQoADwYPGRULABAGEUkCQwMAAAUXCgAuEQ4EBQUJCwABBwonCwEKAA8GDxAVCwIKAA8GDxEVCwAQBhFJAkQDAAAFCgsBOA0KAA8GDxoVCwAQBhFJAkUDAAAFEgoALhEOBAUFCQsAAQcKJwsBCgAPBg8SFQsAEAYRSQJGAwAABQoLATgNCgAPBg8bFQsAEAYRSQJHAwAABRIKAC4RDgQFBQkLAAEHCicLAQoADwYPExULABAGEUkCSAMAAAWPAQoALhEdOA4EEgoADwYPFDgPCgAPBg8MFTgBCgAPBg8UFQoALhEeOA4EJAoADwYPFTgPCgAPBg8NFTgBCgAPBg8VFQoALhEfOA4ENgoADwYPFjgPCgAPBg8OFTgBCgAPBg8WFQoALhEgOA4ESAoADwYPFzgPCgAPBg8PFTgBCgAPBg8XFQoALhEhOBAEZwoADwYPGDgRCgAPBg8QFTgACgAPBg8YFQoADwYPGTgRCgAPBg8RFTgACgAPBg8ZFQoALhEjOBAEeQoADwYPGjgRCgAPBg8SFTgACgAPBg8aFQoALhEkOBAEjAEKAA8GDxs4EQoADwYPExU4AAsADwYPGxUFjgELAAECSQEAAAUECwA4EhFKAkoBAgBLAAAARBgOABAHFAwGCgMRYAwFCwYKAxFrDAQLAAYAAAAAAAAAAAsECgELBQoCBgAAAAAAAAAACwELAgsDEVUSAQIBBAEHAQMBCAEFAQYBAAAAAAUABgAHAAgACQAKAAsADAABAAQAAgADABEAEgATABQADQAOAA8AEAECAQEAJwBrAIkBAIoBAI0BAApzdWlfc3lzdGVt2BuhHOsLBgAAAAwBABwCHD4DWpIDBOwDCgX2A54DB5QHvwwI0xNgBrMUNgrpFAgM8RSmBg2XGwQPmxsCADABHAIQAhICFAIbAi8CMwI0AC0ALgAxAEkASgAGCAABAgcBAAACAAQBAAEDAQwBAAEFCwQABgMCAAgKAgAJBAQACgUIAAsHBAALCAQACwkEAAwNBAANDAwAABMAAQAAIgIBAAAkAwEAACEDAQAAIwMBAAAmBAEAACsEAQAAJQUBAAAqBQEAAB8GAQAAIAcBAAAnCAEAAB4JAQAANQkBAAAoAwEAAD8KAQAAPQoBAAA+CgEAAEcKAQAAQAoBAAA2CgEAAEIKAQAAOAoBAABDCgEAADkKAQAARQoBAAA7CgEAAEQLAQAAOgsBAABGCgEAADwKAQAAQQoBAAA3CgEAAA8MDQAAGQ4PAAAaDhAAABgOEAAEDhYBAgcEBBEnKwIHBAQdJygCBwQHLBgBAQgIKSMkAAsPJQ0ACxMSEwALFgEUAAseIAEACx8dAQALIB4BAAshGgEACyIZAQALIxoBAAskGgEACyUcAQALJhsBAAsnHwEACygaAQALKhwBAAsrGwEACzIPFAALNSABAAs2IQEACzchAQALOCEBAAs5IQEACzoiAQALOyEBAAs8IQEACz0hAQALPiEBAAs/IQEAC0AhAQALQSEBAAtCIQEAC0MhAQALRCIBAAtFIQEAC0YhAQALRyEBAAtIEykAJRUoFycVJSomKggIBAoIDAsCAQgFAwMICwgHBwgGABAHCAAKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIDAwcIBgIHCAAHCAYDBwgABggNAwMHCAADBwgGBAcIAAsDAQgFBQcIBgUHCAAKCwMBCAULAQEDBQcIBgMHCAAICAcIBgMHCAAGCA0FAwcIAAoCBggGBAcIAAoCCgIGCAYLCwIBCAULAgEIBQcIAAMDAwMDAwMHCAYBCwIBCAUBBwgAAQYICgEHCAoDCAAICQMHCggMCwIBCAUDAwgLCAcHCAYBCAkBAwIDCAkDBwgECQAJAQEIAAEJABAHCAoKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIDAwcIBgIHCAoHCAYDBwgKBggNAwMHCAoDBwgGBAcICgsDAQgFBQcIBgUHCAoKCwMBCAULAQEDBQcIBgMHCAoICAcIBgMHCAoGCA0FAwcICgoCBggGBAcICgoCCgIGCAYBBggGAQULBwgKAwMLAgEIBQsCAQgFAwMDAwMHCAYCBwgKCAoCBwgECQABCQEBCAoCAwgKAQcJAQdCYWxhbmNlBENvaW4GT3B0aW9uA1NVSQxTdGFrZVN1YnNpZHkJU3Rha2VkU3VpDlN1aVN5c3RlbVN0YXRlE1N1aVN5c3RlbVN0YXRlSW5uZXIVU3VpU3lzdGVtU3RhdGVJbm5lclYyEFN5c3RlbVBhcmFtZXRlcnMJVHhDb250ZXh0A1VJRB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwCVZhbGlkYXRvcgNhZGQNYWR2YW5jZV9lcG9jaAdiYWxhbmNlCmJvcnJvd19tdXQEY29pbgZjcmVhdGUNZHluYW1pY19maWVsZAdnZW5lc2lzHGdlbmVzaXNfc3lzdGVtX3N0YXRlX3ZlcnNpb24CaWQYbG9hZF9pbm5lcl9tYXliZV91cGdyYWRlEWxvYWRfc3lzdGVtX3N0YXRlFWxvYWRfc3lzdGVtX3N0YXRlX211dAZvYmplY3QGb3B0aW9uBnJlbW92ZRByZXBvcnRfdmFsaWRhdG9yEXJlcXVlc3RfYWRkX3N0YWtlGnJlcXVlc3RfYWRkX3N0YWtlX211bF9jb2luFXJlcXVlc3RfYWRkX3ZhbGlkYXRvch9yZXF1ZXN0X2FkZF92YWxpZGF0b3JfY2FuZGlkYXRlGHJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvciJyZXF1ZXN0X3JlbW92ZV92YWxpZGF0b3JfY2FuZGlkYXRlG3JlcXVlc3Rfc2V0X2NvbW1pc3Npb25fcmF0ZRVyZXF1ZXN0X3NldF9nYXNfcHJpY2UWcmVxdWVzdF93aXRoZHJhd19zdGFrZRRyb3RhdGVfb3BlcmF0aW9uX2NhcAZzZW5kZXInc2V0X2NhbmRpZGF0ZV92YWxpZGF0b3JfY29tbWlzc2lvbl9yYXRlIXNldF9jYW5kaWRhdGVfdmFsaWRhdG9yX2dhc19wcmljZQxzaGFyZV9vYmplY3QNc3Rha2Vfc3Vic2lkeQxzdGFraW5nX3Bvb2wDc3VpCnN1aV9zeXN0ZW0Wc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchRzeXN0ZW1fc3RhdGVfdmVyc2lvbgh0cmFuc2Zlcgp0eF9jb250ZXh0FXVuZG9fcmVwb3J0X3ZhbGlkYXRvcip1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9uZXR3b3JrX2FkZHJlc3MpdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfbmV0d29ya19wdWJrZXkmdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcDJwX2FkZHJlc3MqdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcHJpbWFyeV9hZGRyZXNzKnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3Byb3RvY29sX3B1YmtleSl1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl93b3JrZXJfYWRkcmVzcyh1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl93b3JrZXJfcHVia2V5HHVwZGF0ZV92YWxpZGF0b3JfZGVzY3JpcHRpb24adXBkYXRlX3ZhbGlkYXRvcl9pbWFnZV91cmwVdXBkYXRlX3ZhbGlkYXRvcl9uYW1lK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9uZXR3b3JrX2FkZHJlc3MqdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5J3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wMnBfYWRkcmVzcyt1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfcHJpbWFyeV9hZGRyZXNzK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wcm90b2NvbF9wdWJrZXkqdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3dvcmtlcl9hZGRyZXNzKXVwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF93b3JrZXJfcHVia2V5HHVwZGF0ZV92YWxpZGF0b3JfcHJvamVjdF91cmwIdjFfdG9fdjIJdmFsaWRhdG9yDXZhbGlkYXRvcl9jYXAHdmVyc2lvbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhcIBEsDAAMAABEXCwELAgsDCwQLBQsGCwcRKwwJESwMCgsACgoSAAwIDQgPAAsKCwk4AAsIOAECAQEEAAETCwARIwsBCwILAwsECwULBgsHCwgLCQsKCwsLDAsNCw4LDxExAgIBBAABBQsAESMLAREzAgMBBAABBQsAESMLAREwAgQBBAABBQsAESMLAREyAgUBBAABBgsAESMLAQsCETUCBgEEAAEGCwARIwsBCwIROQIHAQQAAQYLABEjCwELAhE0AggBBAABBgsAESMLAQsCETgCCQEEAAEHCwARIwsBCwILAxEuAgoBBAABCAsAESMLAQsCCwMLBBEvAgsBBAABBgsAESMLAQsCETYCDAEEAAEGCwARIwsBCwIRLQINAQQAAQYLABEjCwELAhE7Ag4BBAABBQsAESMLARE3Ag8BBAABBgsAESMLAQsCEUUCEAEEAAEGCwARIwsBCwIRQwIRAQQAAQYLABEjCwELAhFEAhIBBAABBgsAESMLAQsCEU0CEwEEAAEGCwARIwsBCwIRRgIUAQQAAQYLABEjCwELAhE8AhUBBAABBgsAESMLAQsCEUgCFgEEAAEGCwARIwsBCwIRPgIXAQQAAQYLABEjCwELAhFJAhgBBAABBgsAESMLAQsCET8CGQEEAAEGCwARIwsBCwIRSwIaAQQAAQYLABEjCwELAhFBAhsBBAABBwsAESMLAQsCCwMRSgIcAQQAAQcLABEjCwELAgsDEUACHQEEAAEGCwARIwsBCwIRTAIeAQQAAQYLABEjCwELAhFCAh8BBAABBgsAESMLAQsCEUcCIAEEAAEGCwARIwsBCwIRPQIhAAAAEB0LAhEjDAsKCi4RKQcCIQQKBRALCwELCgEHACcLCwsDCwQLAAsBCwULBgsHCwgLCQsKESoCIgAAAAEECwARJC4CIwAAAAEDCwARJAIkAAAAJi8KABABFAYBAAAAAAAAACEEGQoADwAKABABFDgCEU4MAgYCAAAAAAAAAAoADwEVCgAPAAoAEAEUCwI4AwoADwAKABABFDgEDAEKAS4ROgsAEAEUIQQpBS0LAQEHAScLAQIAAAABABUADHN0YWtpbmdfcG9vbMgeoRzrCwYAAAAMAQAWAhY6A1CvAgT/AiYFpQPgAgeFBpAJCJUPYAb1D8gBCr0RQgz/Ee0LDewdHA+IHgQASQEwAg8CEAITAisCLwJKAk0CTgJPAAgMAAAFBwAABwgAAQQHAQAAAgAMAAMBBAEAAQQCDAEAAQYDBwAGCwQABwYCAAgJDAIHAQQBCgoCAAAtAAEAAD8CAwAAQAQFAABUBgcAAFAICQAAGAoDAAA9CwMAADwMAwAAOwwDAABVDQkAAAwOAwAAQQQFAAAVDgMAAEwPBQAANhARAABIEAUAAEcQBQAAJg8SAAAkDxIAAEUTCAAARhMDAAAqFAMAACMVEgAAORYXAAAzDwUAADQPBQAAJxYSAAAeGAUAAB8YBQAAIgMXAAASFgMAARE0IwEAARwxAwEAASA2MwEDASU0EgEAASg0EgEAAS4DHQEAAUQzHQEAAi0AIAADKSgFAQADRTAfAQADUyIFAQADVgMfAQAEHSkqAQAFLC0FAAYXHAMABiEjEQEIBi0AHAAIDi4DAgcECBE3OAIHBAgUNxICBwQILQAbAgcECT4kAwEMCU4kAwEIChkmBQAKQyYnADMaJAUqHikeLgE1CCceKx40KzAaKB4gBSUFIgUjBSEFHwUyGjEaAQcICwEIAAUHCAALBQEICQUDBwgLAAMHCAAIAgcICwEDAgcIAAgCAgMLBQEICQEIAgELBQEICQIHCAALBQEICQIHCAAHCAsBBwgABAcIAAMDAwIHCAADAQYIAAEGCAIBCAcBAQMHCAIDBwgLAgcIAggCAgYIAgYIAgIGCAADAQgBAgYIAQMBCwoCAwgBAgMIAQELCgIJAAkBAQgIAQsDAQkAAQgJAQsFAQkAAQgEAggCAwEGCwUBCQABBgkAAgkABQYDCwUBCAkDCwUBCAkFAwEGCAsBBQIHCwUBCQALBQEJAAILBQEJAAcICwELBgEJAAELBgEICQMDCAELBQEICQIDAwMHCwoCCQAJAQkACQEFAwMIAQMDAgcLBQEJAAMCBwsDAQkACQADCwUBCAkFAwEJAAEGCwMBCQACBggCCwUBCAkCBgsDAQkACQACBgsKAgkACQEJAAEGCQEDAwgBAwNCYWcHQmFsYW5jZQRDb2luAklEBk9wdGlvbhVQb29sVG9rZW5FeGNoYW5nZVJhdGUDU1VJCVN0YWtlZFN1aQtTdGFraW5nUG9vbAVUYWJsZQlUeENvbnRleHQDVUlEFWFjdGl2YXRlX3N0YWtpbmdfcG9vbBBhY3RpdmF0aW9uX2Vwb2NoA2FkZANiYWcHYmFsYW5jZQZib3Jyb3cYY2hlY2tfYmFsYW5jZV9pbnZhcmlhbnRzBGNvaW4IY29udGFpbnMXZGVhY3RpdmF0ZV9zdGFraW5nX3Bvb2wSZGVhY3RpdmF0aW9uX2Vwb2NoBmRlbGV0ZQ9kZXBvc2l0X3Jld2FyZHMFZXBvY2gOZXhjaGFuZ2VfcmF0ZXMMZXh0cmFfZmllbGRzBGZpbGwMZnJvbV9iYWxhbmNlDmdldF9zdWlfYW1vdW50EGdldF90b2tlbl9hbW91bnQQZ2V0X3dpdGhfZGVmYXVsdAJpZBVpbml0aWFsX2V4Y2hhbmdlX3JhdGUZaXNfZXF1YWxfc3Rha2luZ19tZXRhZGF0YQtpc19pbmFjdGl2ZQdpc19ub25lDGlzX3ByZWFjdGl2ZRVpc19wcmVhY3RpdmVfYXRfZXBvY2gHaXNfc29tZQRqb2luD2pvaW5fc3Rha2VkX3N1aQRtYXRoA21pbgNuZXcEbm9uZQZvYmplY3QGb3B0aW9uG3BlbmRpbmdfcG9vbF90b2tlbl93aXRoZHJhdw1wZW5kaW5nX3N0YWtlFHBlbmRpbmdfc3Rha2VfYW1vdW50HXBlbmRpbmdfc3Rha2Vfd2l0aGRyYXdfYW1vdW50GnBlbmRpbmdfdG90YWxfc3VpX3dpdGhkcmF3B3Bvb2xfaWQRcG9vbF90b2tlbl9hbW91bnQScG9vbF90b2tlbl9iYWxhbmNlIXBvb2xfdG9rZW5fZXhjaGFuZ2VfcmF0ZV9hdF9lcG9jaAlwcmluY2lwYWwVcHJvY2Vzc19wZW5kaW5nX3N0YWtlHnByb2Nlc3NfcGVuZGluZ19zdGFrZV93aXRoZHJhdyRwcm9jZXNzX3BlbmRpbmdfc3Rha2VzX2FuZF93aXRoZHJhd3MPcHVibGljX3RyYW5zZmVyEXJlcXVlc3RfYWRkX3N0YWtlFnJlcXVlc3Rfd2l0aGRyYXdfc3Rha2UgcmVxdWVzdF93aXRoZHJhd19zdGFrZV9wcmVhY3RpdmUMcmV3YXJkc19wb29sBnNlbmRlcgRzb21lBXNwbGl0EHNwbGl0X3N0YWtlZF9zdWkWc3Rha2VfYWN0aXZhdGlvbl9lcG9jaBFzdGFrZWRfc3VpX2Ftb3VudAxzdGFraW5nX3Bvb2wDc3VpCnN1aV9hbW91bnQLc3VpX2JhbGFuY2UFdGFibGUIdHJhbnNmZXIKdHhfY29udGV4dBF1bndyYXBfc3Rha2VkX3N1aQl2YWxpZGF0b3INdmFsaWRhdG9yX3NldAV2YWx1ZRd3aXRoZHJhd19mcm9tX3ByaW5jaXBhbBB3aXRoZHJhd19yZXdhcmRzBHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCADKmjsAAAAAAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMICgAAAAAAAAADCAsAAAAAAAAAAwgMAAAAAAAAAAMIDQAAAAAAAAADCA4AAAAAAAAAAwgPAAAAAAAAAAMIEAAAAAAAAAADCBEAAAAAAAAAAwgSAAAAAAAAAAACCyEICA0LAwEDFgsDAQNMA0ILBQEICTgDGgsKAgMIATIDNQMxAxsIBAECAksDNwMCAgQhCAg2CAdHAzoLBQEICQADAAAZEgoAOAAMAQoAES84ATgBBgAAAAAAAAAAOAIGAAAAAAAAAAALAQYAAAAAAAAAAAYAAAAAAAAAAAYAAAAAAAAAAAsAESYSAAIBAwAAIS8OATgDDAYKAC4REiAECQUPCwABCwQBBwsnCgYGAAAAAAAAAAAkBBQFGgsAAQsEAQcSJwsEES8KAC44BAsDCwESAgwFCgAQABQLBhYLAA8AFQsFCwI4BQICAwAAJT0KAAsBEQMMBAwDCgIuETcMBw4EOAMMBQoACgUKAwoCLhE2EQkMBgsFDgY4AxYMCAoAEAEUCggWCgAPARUKABACFAsDFgoADwIVCgAuERIEMAsAEQcFMgsAAQ0ECwY4BgELBAsCOAcLBzgICwgCAwMAACwfDgEQAxQKAC44BCEECQUNCwABBwInCwAOARAEFAwCLgsCERcMAwsBEQQMBA4DDgQ4AxEcCwQCBAAAAAkICwATAgwBAQERLQsBAgUDAAADDwoAEAUUDgE4AxYKAA8FFQsADwYLATgGAQIGAwAALRwLAS4RNgYBAAAAAAAAABYMAwoAEQcKABEICgAPBwoDCgAQBRQKABAIFBIBOAkLAAsDDAIuCwIRHgIHAAAAAx0KABAFFAoAEAEUFwoADwUVCgAQCBQKABACFBcKAA8IFQYAAAAAAAAAAAoADwEVBgAAAAAAAAAACwAPAhUCCAMAABcfCgAQBRQKABAIFBIBDAEKABAFFAoAEAAUFgoADwUVDgEKABAFFBEcCgAPCBUGAAAAAAAAAAALAA8AFQIJAAAALyEKAAsDDAQuCwQRFwwGDgYLAhEbDAgKCAoBJgQUCwgLARcMBQUWBgAAAAAAAAAADAULBQoAEAY4AxEsDAcLAA8GCwc4CgIKAwAAAx0KAA8HCgERHTgJCgAuEREECgUOCwABBw8nCgAuERIgBBQFGAsAAQcRJwsADwkLATgLAgsDAAAyOw4BEAMUCgAuOAQhBAkFDwsAAQsCAQcCJwoALhERBBQFGgsAAQsCAQcQJwoCLhE3DAQLAREEDAMOAzgDDAUKABAFFAoFFwoADwUVCgAQCBQKBRcLAA8IFQsDCwI4BwsEOAgLBQIMAwAAAxAKAC4REiAEBgUKCwABBwwnCwE4DAsADwoVAg0BAAADBAsAEAUUAg4BAAADBAsAEAMUAg8BAAADBAsAEAs4AwIQAQAAAwQLABAEFAIRAQAAAwQLABAJOA0CEgEAAAMECwAQCjgOAhMBAAADDgsCES8KABADFAoAEAQUCwAPCwsBOAoSAgIUAQQABTAKABALOAMMAwoBCgMlBAkFDwsAAQsCAQcEJwsDCgEXBwAmBBYFHAsAAQsCAQcTJwoBBwAmBCEFJwsAAQsCAQcTJwsACwEKAhETCwIuETc4BQIVAQQANRgKAA4BDAIuCwIRFgQIBQwLAAEHDScLARMCDAMBAREtCwAPCwsDOAYBAhYBAAASGQoAEAMUCgEQAxQhBBELABAEFAsBEAQUIQwCBRcLAAELAQEJDAILAgIXAQAALS0KAAoBERoECAsAAREdAgoAEAoKATgPCwERLAwDCgAQCTgQFAwCCgMKAiYEKQUZCgAQBwoDOBEEJAsAEAcLAzgSFAILAwYBAAAAAAAAABcMAwUUCwABER0CGAEAAAMECwAQABQCGQEAAAMECwAQARQCGgAAABIRCgAREQQICwABCAwCBQ8LABAJOBAUCwEkDAILAgIbAAAAEiMKABAMFAYAAAAAAAAAACEECQgMAgUPCgAQDRQGAAAAAAAAAAAhDAILAgQVCwABCwECCgAQDBQ1CwE1GAsAEA0UNRo0AhwAAAASIwoAEAwUBgAAAAAAAAAAIQQJCAwCBQ8KABANFAYAAAAAAAAAACEMAgsCBBULAAELAQIKABANFDULATUYCwAQDBQ1GjQCHQAAAAMEBgAAAAAAAAAABgAAAAAAAAAAEgECHgAAADkWCgALAREXDAMOAwoAEAUUERwMBAsAEAgUDAILBAsCIQQTBRUHCicCAAcACAAJAgECAgADAAQABgAFAAEAAgIDAQABAQBRAFIADHN0b3JhZ2VfZnVuZLUEoRzrCwYAAAALAQAGAgYOAxQsBEAIBUhJB5EBsgEIwwJACoMDDwySA2sN/QMED4EEAgAJAQQBCgACBAABAAQBAAECAQIAAAYAAQAAAwIAAAANAwQAAAwDBAABBQgEAQABCAkHAQABDgoEAQABDwUHAQAHBgQGBQYGBgELAQEIAgEIAAYHCAALAQEIAgsBAQgCCwEBCAIDAwEGCAABAwABCAIBCwEBCQACBwsBAQkACwEBCQACBwsBAQkAAwEGCwEBCQAHQmFsYW5jZQNTVUkLU3RvcmFnZUZ1bmQNYWR2YW5jZV9lcG9jaAdiYWxhbmNlBGpvaW4DbmV3Fm5vbl9yZWZ1bmRhYmxlX2JhbGFuY2UFc3BsaXQMc3RvcmFnZV9mdW5kA3N1aRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyDXRvdGFsX2JhbGFuY2UcdG90YWxfb2JqZWN0X3N0b3JhZ2VfcmViYXRlcwV2YWx1ZQR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgACAg0LAQEIAgcLAQEIAgADAAAFBDgACwASAAIBAwAAAB4KAA8ACwI4AQEKAA8ACwM4AQEKAA8BCwE4AQEKAA8BCwU4AgwGCgAPAAsGOAEBCwAPAQsEOAICAgEAAAUECwAQATgDAgMBAAAFCAoAEAE4AwsAEAA4AxYCAAEAAAALAAx2b3RpbmdfcG93ZXKXDaEc6wsGAAAADAEACAIIDAMUVwRrBAVvhgEH9QGwAgilBGAGhQVGCssFEAzbBf4GDdkMBA/dDAIAFgEVAgkAEgABAgAAAgIAAwAEAAANAAEAAAYCAwAADwQFAAAHBgEAAAMHAQAAEQgBAAAEBAEAABABBQAADAEFAAEHEQEBAAEIExQBAAIFCwUAAgoLBQACCwsFAAMNFQEAAw8OBQADFg4FAAkNCg0BBwoIAgACBgoIAgMCCggBAwEGCggCAQMCBwoIAQgBAwcKCAEDAwIHCggCCggBBAMKCAEDAwEIAgIDAwgDCAEDCggBAwMDAwEIAQEGCAIDAwMDBAMBAwMDBwoJAAkAAwcBAwMDAwMHCAEBBgoJAAEBAgcIAgMMAwMDAwMDAwMDBggCBggCAwlWYWxpZGF0b3IPVm90aW5nUG93ZXJJbmZvEVZvdGluZ1Bvd2VySW5mb1YyE2FkanVzdF92b3RpbmdfcG93ZXIQY2hlY2tfaW52YXJpYW50cxNkaXZpZGVfYW5kX3JvdW5kX3VwFmluaXRfdm90aW5nX3Bvd2VyX2luZm8GaW5zZXJ0CGlzX2VtcHR5BG1hdGgDbWF4A21pbhBxdW9ydW1fdGhyZXNob2xkEHNldF92b3RpbmdfcG93ZXIFc3Rha2ULdG90YWxfc3Rha2USdG90YWxfdm90aW5nX3Bvd2VyE3VwZGF0ZV92b3RpbmdfcG93ZXIJdmFsaWRhdG9yD3ZhbGlkYXRvcl9pbmRleA12YWxpZGF0b3Jfc2V0BnZlY3Rvcgx2b3RpbmdfcG93ZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCBAnAAAAAAAAAwgLGgAAAAAAAAMI6AMAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAAICEwMWAwECAxMDFgMOAwADAAAJHQcABwIHAAoALkEKEQsRDBENDAQKAAoEDAEuCwERAQwDDAINAgsECwMRBAoACwIRBQsALhEGAgEAAAAMOgoAEQIMCAYAAAAAAAAAAAwCCgBBCgwEBgAAAAAAAAAADAdADQAAAAAAAAAADAUKAgoEIwQzBREKAAoCQgoRDwwGCgY1BwA1GAoINRo0CgERDQwJCgIKCQsGEgEMAw0FCwMRAwsHCwkWDAcLAgYBAAAAAAAAABYMAgUMCwABCwUHAAsHFwICAAAADxwGAAAAAAAAAAAMAQoAQQoMAgYAAAAAAAAAAAwDCgEKAiMEGAUMCwMKAAoBQgoRDxYMAwsBBgEAAAAAAAAAFgwBBQcLAAELAwIDAAAAECcGAAAAAAAAAAAMBAoALkENDAUKBAoFIwQZBQsKAAoEDAIuCwJCDRAAFA4BEAAUJAwDBRsJDAMLAwQiCwQGAQAAAAAAAAAWDAQFBgsACwELBDgAAgQAAAASVAYAAAAAAAAAAAwFCgAuQQ0MBgoFCgYjBBAFCwoCBgAAAAAAAAAAJAwDBRIJDAMLAwRKCgAKBUMNDAkKAgoGCgUXEQsMBwoBCgkQARQLBxYRDQwICgILCAoJEAEUFxENDAQKCRABFAoEFgoJDwEVCwkQARQKASUEPQVBCwABBwUnCwILBBcMAgsFBgEAAAAAAAAAFgwFBQYLAAELAgYAAAAAAAAAACEEUQVTBwMnAgUAAAALFg4BOAEgBBEFBQ0BRQ0TAQEMAwwCCgALAkMKCwMRDgUACwABCwFGDQAAAAAAAAAAAgYAAAAWdwYAAAAAAAAAAAwDCgBBCgwEBgAAAAAAAAAADAkKAwoEIwQjBQwKAAoDQgoREAwMCgwGAAAAAAAAAAAkBBYFGgsAAQcGJwsJCwwWDAkLAwYBAAAAAAAAABYMAwUHCwkHACEEKAUsCwABBwMnBgAAAAAAAAAADAEKAQoEIwR0BTMKAQYBAAAAAAAAABYMAgoCCgQjBG8FPAoACgFCCgwKCgAKAkIKDAsKChEPDAcKCxEPDAgLChEQDAULCxEQDAYKBwoIJARdCgUKBiYEWQVdCwABBwQnCwcLCCMEagsFCwYlBGYFagsAAQcEJwsCBgEAAAAAAAAAFgwCBTcLAQYBAAAAAAAAABYMAQUuCwABAgcBAAABAgcAAggBAAABAgcBAgECAQEAFAANc3Rha2Vfc3Vic2lkea4GoRzrCwYAAAAMAQAMAgwWAyIlBEcEBUtKB5UBsAIIxQNABoUEHAqhBBQMtQS0AQ3pBQoP8wUEABIBBgEHAQ4BFQEXAAMEAAEADAACAQQBAAEEAgIABQQCAAAIAAEAAAUCAwAACgQFAAEQBwgAAhENDgEAAhgLBQEAAw8MBQAFCgQKBQsCAQgDAwMNBwgEAQgAAQcIAAELAgEIAwEGCAABAwABBwgEAQgBAwQLAgEIAwMBCAMBBgsCAQkAAgMDAgcLAgEJAAMBCwIBCQADQmFnB0JhbGFuY2UDU1VJDFN0YWtlU3Vic2lkeQlUeENvbnRleHQNYWR2YW5jZV9lcG9jaANiYWcHYmFsYW5jZQZjcmVhdGUbY3VycmVudF9kaXN0cmlidXRpb25fYW1vdW50HGN1cnJlbnRfZXBvY2hfc3Vic2lkeV9hbW91bnQUZGlzdHJpYnV0aW9uX2NvdW50ZXIMZXh0cmFfZmllbGRzB2dlbmVzaXMEbWF0aANtaW4DbmV3BXNwbGl0DXN0YWtlX3N1YnNpZHkbc3Rha2Vfc3Vic2lkeV9kZWNyZWFzZV9yYXRlG3N0YWtlX3N1YnNpZHlfcGVyaW9kX2xlbmd0aANzdWkWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lcgp0eF9jb250ZXh0BXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgQQECcAAAAAAAAAAAAAAAAAAAMIAAAAAAAAAAAAAgYHCwIBCAMLAwkDFAMTDQwIAQADAAAGEwoDBwBLJQQGBQoLBAEHAScLAAYAAAAAAAAAAAsBCwILAwsEEQMSAAIBAwAACTkKABAAFAoAEAE4ABEGDAMKAA8BCwM4AQwCCgAQAhQGAQAAAAAAAAAWCgAPAhUKABACFAoAEAMUGQYAAAAAAAAAACEENQoAEAAUNQoAEAQUNRgHABoMAQoAEAAUCwE0FwsADwAVBTcLAAELAgICAQAABggKABAAFAsAEAE4ABEGAgACAAAAAQADAAQADQAWAA12YWxpZGF0b3JfY2FwgQahHOsLBgAAAAwBAAgCCBQDHCoERgQFSjYHgAHiAgjiA0AGogQiCsQEDQzRBHANwQUED8UFBgASAQoBDgEPAAMMAAAEAgABAAcAAQIEAAMBAgAAEAABAAAUAgEAAAkDBAAACAAFAAEGDQQBCAEHCgsAAgsOBgEMAwwICQAEDAYMAQYIAAEGBQEGCAECBQcIBAEIAgEIAQAEAQgACAIFAQYIBAEFAQcIBAEIAwEIAAEGCQACCQAFAklECVR4Q29udGV4dANVSUQfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcBVWYWxpZGF0b3JPcGVyYXRpb25DYXAcYXV0aG9yaXplcl92YWxpZGF0b3JfYWRkcmVzcwJpZANuZXcTbmV3X2Zyb21fdW52ZXJpZmllZDNuZXdfdW52ZXJpZmllZF92YWxpZGF0b3Jfb3BlcmF0aW9uX2NhcF9hbmRfdHJhbnNmZXIGb2JqZWN0D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lcgh0cmFuc2Zlcgp0eF9jb250ZXh0IHVudmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzCXZhbGlkYXRvcg12YWxpZGF0b3JfY2FwDXZhbGlkYXRvcl9zZXQedmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIGCAMFBQECAQUFAAMAAAYDCwAQAAIBAwAABgMLABABAgIDAAAHIwoBLhEHDAUKBQcAIQQLCAwCBQ8LBQoAIQwCCwIEEgUWCwEBBgAAAAAAAAAAJwsBEQUKABIADAMOAzgADAQLAwsAOAELBAIDAwAABgULABAAFBIBAgABAQAADQARABMADXZhbGlkYXRvcl9zZXS2UKEc6wsGAAAADAEAMwIzcAOjAYYGBKkHhQEFrgjSCQeAErcXCLcpYAaXKsMBCtorjQEM5yz7Ig3iTxAP8k8FAJ8BAWcBpwECHgIfAjkCZQJxAo0BApEBApIBApgBAqUBAqYBAIkBAJsBAJ4BAKMBAKoBABMEAAAOAwAADwMAABADAAARAwABBAcBAAADAAwABAEEAQABBgMHAAcCBgECAAcGBgECAAgHAgAJCQwCBwEEAQoKBAEEAQsLAgAMFQcCAQAAAA0WBwEDAA4FBwAOCAgADw0EABAMDAAQEgIAERQEAABgAAEAAHwCAwAAfgQDAAB7BQMAABwGAwAAfQQDAAB6BwMAAIABCAMAAH8JAwAAGwoDAACaAQsDAAA0DAMAAC8NDgAAlQENDgAAogEPDgAAoAEPDgAAoQEPEAAAiwENEQAAYw0OAABRDxIAAFQGEgAAUxMSAAArEw4AAFUGEgAAKhQOAABEFRYAADwXGAAAPRkYAABHGhsAAEgcFgAAQR0WAABLHhYAAEkfFgAASh8WAABMFyAAAEIhIAAAQw8gAABGDyAAAKkBIiMAAHIkAwAAdSUDAAAjJgMAAHQnAwAAhQEoAwAAcykDAAAiKg4AABorAwAAJiwtAAAnLi8AACgwMQAAJTIxAAAzMwMAADY0AwAAkAEaDgAAGA0qAABaDxIAAFc1EgABMW9RAQABO1BRAQABWU8SAQABZANvAQABhAFRbwEAAilSEgEAAlZ9EgEAAnlhUQEAA2A4QgAEMpQBAwEABFyVAQ4BAASGAZMBlAEBAASkAVQOAQAFNVEDAQMGTW4QAQgHYGdoAQIHYWVmAQIHcGllAQIJGTwDAgcECSBEVwIHBAkhSVkCBwQJKUQSAgcECWA4OQIHBAl5SUoCBwQKIG1uAQQKIXJzAQQKNzg9AQQKVmoSAQQKXmoOAQQKb4cBUQEECnZNAwEECzhIDgALgQFIOwAMKV0SAgEADDcDQQIBAAxAXVcCAQAMRV5ZAgEADE9gAwIBAAxWggESAgEADF2CAYMBAgEADG6OAV8CAQAMeV5fAgEADIMBggEOAgEADSmEARIBAw1QjwGDAQEDDVaGARIBAw15hQEDAQMOalYQAA8XSwMADxoWAwAPJCAOAA8tSwMADy6WAQMADzQWAwAPPiAOAA9SbBIAD1ggEgAPZiB7AA9tmAGZAQAPc4oBAwAPelUDAA9/SwMAD4ABWAMAD4gBIA4AD4oBIBAAD44BIDsAD5YBIA4AD6oBIA4AEGJ5IwAQmQF5dQAQqAF0dQARLEVGABEwRjoAEV9aFgASdwMOABKCASsDABKXAQMOAE83SzdTOk8+Tz9bQE4/Sz9QP1A3Sz5XOjsOOg4+DkVTTjdMN04+TT5aQGJAXUBeQEA6SQ5IDkoOVTpROk0/PQ48DjkOUjpHej8ORn9agQFigQFggQFdgQFkO2c7ZjtUOlY6RogBW2JeYl+BAWGBAWU7Y2JaYlxiRFNDU0JTXIEBPjtGmgECCggTBwgOAQgAAwcIAAgTBwgOAAIHCAAHCA4DBwgAAwcIDgIGCAAGCBMEBwgABQsHAQgLBwgOAwcIAAgSBwgOAwcIAAMGCA4JBwgABwsHAQgLBwsHAQgLBwsPAgULEAEFAwMDAwcIDgYHCAADAwMHCw8CBQsQAQUHCA4BBwgAAQYIAAEDAgYIAAUBCAgBBgsMAggIBQEBAgYKCBMGCBMCBgsNAQgTBggTAgcIAAUBBwgTAgYKCBMFAQsFAQMCBgsNAQgTBQIGCggTBgoFAQoDAgcKCBMFAwcIAAUBAwcIAAYIFQECBwgABggOAQYIEwMHCAAFAgMHCAAGCBQCAQgVAwcIAAcLDwIFCxABBQcIDgUHCAAIEwcLDwIFCxABBQEHCA4CBwsPAgULEAEFBQIHCAADAQcKAwIHCggTBwgOAQYKCBMBBwoIEwQKAwMGCgMGCgMEAwsPAgMDAwsPAgMDAgYIAAsPAgULEAEFAQoFBAYKCBMDAwMCCgMKAwkGCggTAwMKAwoDAwsPAgMDAwsPAgMDBgcKCBMGCgMGCgMHCwcBCAsHCwcBCAsHCA4GAwYKCBMGCgMGCgMGCw8CBQsQAQUGCgUCBggACAgGAwMLDAIICAUDBggTCAACCAgFAQcIDgELDAIJAAkBAQgTAQUDBwsMAgkACQEJAAkBAQsNAQkAAggICBYCBQgWAgUDAQsPAgkACQEBCAYEBggTBggTAQUCBgsMAgkACQEJAAIIEwcIDgEIFgMICAgTBQEGCA4CBwsMAgkACQEJAAEJAQIHCBMDBQYIEwYIEwEIEwUCBwsNAQkACQADBQMLBQEDAQYLBQEJAAEHCwUBCQABCQACBgoJAAYJAAEICwEGCwcBCQAEBwgTCwcBCAsFBwgOAQYIEgEGCQEDBwgTCBIHCA4BBwkBAQcIFg4LDwIFCxABBQYKBQoDCgMLDwIDAwsPAgMDAwoFAwMDAwoDCgMIAwMHAwMIEwgTBQYIEwIGCw8CCQAJAQYJAAIHCw8CCQAJAQYJAAIJAAkBAwcLDwIJAAkBCQAJAQIHCgkAAwIDAwoKCwkBAwMDCwoBAwMDAwMGCBMGCggTAQsJAQMCAwkAAQsJAQkAAQoLCQEJAAELCgEJAAEHCwoBCQABBgsNAQkAAwMDAwIGCBMGCBMCBgsNAQkAAwEGCQABCwUBCQAFBQMLBQEDAwoDBAMDCwUBAwsFAQMCBwsNAQkAAwEHCQABBggVAQYFAgMLBQEDBgEBAwMLBQEDCwUBAwUFBggTCAgFBggTAQYIFAEIFAEGCAgCAwgTAQYKCQADAwUICAEIBAcGBQYFAwMGBQoFBwsQAQUCBQsQAQUBBgsPAgkACQEBCgkAAgYLEAEJAAYJAAIHCxABCQAGCQABBgsQAQkAAQcLDQEJAAEIAwYDAwMDAwMCBwgTBwgOBAMDAwYIEwcLDwIDAwsPAgMDBAQDAwMFCgUGCggTCxABBQoFBQEHCw8CCQAJAQELEAEJAAYDAwQKAwoDAxEDAwMKAwMKAwMEAwMDAwMDAwMECAMDCwcBCAsDBwgTBQQLBwEICwIHCwcBCQADAQsHAQkAAgcLBwEJAAsHAQkAAgcIEwsHAQgLCAoFAwMDAwoFBggTBQIGCBMDAQgRAQgCA0JhZwdCYWxhbmNlBUVudHJ5AklEBk9wdGlvbhVQb29sVG9rZW5FeGNoYW5nZVJhdGUNUHJpb3JpdHlRdWV1ZQNTVUkJU3Rha2VkU3VpBVRhYmxlCFRhYmxlVmVjCVR4Q29udGV4dB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwCVZhbGlkYXRvchdWYWxpZGF0b3JFcG9jaEluZm9FdmVudBlWYWxpZGF0b3JFcG9jaEluZm9FdmVudFYyElZhbGlkYXRvckpvaW5FdmVudBNWYWxpZGF0b3JMZWF2ZUV2ZW50FVZhbGlkYXRvck9wZXJhdGlvbkNhcAxWYWxpZGF0b3JTZXQQVmFsaWRhdG9yV3JhcHBlcgZWZWNNYXAGVmVjU2V0CGFjdGl2YXRlEWFjdGl2ZV92YWxpZGF0b3JzA2FkZBphZGp1c3Rfc3Rha2VfYW5kX2dhc19wcmljZQ1hZHZhbmNlX2Vwb2NoJmFzc2VydF9ub19wZW5kaW5nX29yX2FjdGl2ZV9kdXBsaWNhdGVzEmF0X3Jpc2tfdmFsaWRhdG9ycwNiYWcHYmFsYW5jZQZib3Jyb3cKYm9ycm93X211dBZjYWxjdWxhdGVfdG90YWxfc3Rha2VzJmNsZWFuX3JlcG9ydF9yZWNvcmRzX2xlYXZpbmdfdmFsaWRhdG9yD2NvbW1pc3Npb25fcmF0ZSRjb21wdXRlX2FkanVzdGVkX3Jld2FyZF9kaXN0cmlidXRpb24aY29tcHV0ZV9yZXdhcmRfYWRqdXN0bWVudHMaY29tcHV0ZV9zbGFzaGVkX3ZhbGlkYXRvcnMmY29tcHV0ZV91bmFkanVzdGVkX3Jld2FyZF9kaXN0cmlidXRpb24IY29udGFpbnMZY291bnRfZHVwbGljYXRlc190YWJsZXZlYxRjb3VudF9kdXBsaWNhdGVzX3ZlYwljcmVhdGVfdjEKZGVhY3RpdmF0ZRVkZXBvc2l0X3N0YWtlX3Jld2FyZHMaZGVyaXZlX3JlZmVyZW5jZV9nYXNfcHJpY2UHZGVzdHJveQxkZXN0cm95X3NvbWUMZGVzdHJveV96ZXJvEWRpc3RyaWJ1dGVfcmV3YXJkGmVmZmVjdHVhdGVfc3RhZ2VkX21ldGFkYXRhBGVtaXQbZW1pdF92YWxpZGF0b3JfZXBvY2hfZXZlbnRzBWVtcHR5BWVwb2NoBWV2ZW50DGV4dHJhX2ZpZWxkcwdleHRyYWN0DmZpbmRfdmFsaWRhdG9yHWZpbmRfdmFsaWRhdG9yX2Zyb21fdGFibGVfdmVjCWdhc19wcmljZQdnZW5lc2lzA2dldDBnZXRfYWN0aXZlX29yX3BlbmRpbmdfb3JfY2FuZGlkYXRlX3ZhbGlkYXRvcl9tdXQwZ2V0X2FjdGl2ZV9vcl9wZW5kaW5nX29yX2NhbmRpZGF0ZV92YWxpZGF0b3JfcmVmGGdldF9hY3RpdmVfdmFsaWRhdG9yX3JlZiVnZXRfY2FuZGlkYXRlX29yX2FjdGl2ZV92YWxpZGF0b3JfbXV0B2dldF9tdXQZZ2V0X3BlbmRpbmdfdmFsaWRhdG9yX3JlZhVnZXRfdmFsaWRhdG9yX2luZGljZXMRZ2V0X3ZhbGlkYXRvcl9tdXQaZ2V0X3ZhbGlkYXRvcl9tdXRfd2l0aF9jdHgvZ2V0X3ZhbGlkYXRvcl9tdXRfd2l0aF9jdHhfaW5jbHVkaW5nX2NhbmRpZGF0ZXMjZ2V0X3ZhbGlkYXRvcl9tdXRfd2l0aF92ZXJpZmllZF9jYXARZ2V0X3ZhbGlkYXRvcl9yZWYCaWQTaW5hY3RpdmVfdmFsaWRhdG9ycwZpbnNlcnQJaW50b19rZXlzImlzX2FjdGl2ZV92YWxpZGF0b3JfYnlfc3VpX2FkZHJlc3MMaXNfZHVwbGljYXRlFmlzX2R1cGxpY2F0ZV92YWxpZGF0b3IiaXNfZHVwbGljYXRlX3dpdGhfYWN0aXZlX3ZhbGlkYXRvciNpc19kdXBsaWNhdGVfd2l0aF9wZW5kaW5nX3ZhbGlkYXRvcghpc19lbXB0eRVpc19pbmFjdGl2ZV92YWxpZGF0b3IMaXNfcHJlYWN0aXZlB2lzX3NvbWUWaXNfdmFsaWRhdG9yX2NhbmRpZGF0ZQxpc192b2x1bnRhcnkEam9pbgRrZXlzBmxlbmd0aBxsb2FkX3ZhbGlkYXRvcl9tYXliZV91cGdyYWRlA25ldwluZXdfZW50cnkTbmV3X2Zyb21fdW52ZXJpZmllZBpuZXh0X2Vwb2NoX3ZhbGlkYXRvcl9jb3VudARub25lBm9iamVjdBBvcGVyYXRpb25fY2FwX2lkBm9wdGlvbhlwZW5kaW5nX2FjdGl2ZV92YWxpZGF0b3JzEHBlbmRpbmdfcmVtb3ZhbHMHcG9vbF9pZBNwb29sX3N0YWtpbmdfcmV3YXJkGHBvb2xfdG9rZW5fZXhjaGFuZ2VfcmF0ZSFwb29sX3Rva2VuX2V4Y2hhbmdlX3JhdGVfYXRfZXBvY2gDcG9wCHBvcF9iYWNrB3BvcF9tYXgOcHJpb3JpdHlfcXVldWUYcHJvY2Vzc19wZW5kaW5nX3JlbW92YWxzJHByb2Nlc3NfcGVuZGluZ19zdGFrZXNfYW5kX3dpdGhkcmF3cxpwcm9jZXNzX3BlbmRpbmdfdmFsaWRhdG9ycxtwcm9jZXNzX3ZhbGlkYXRvcl9kZXBhcnR1cmUJcHVzaF9iYWNrEHF1b3J1bV90aHJlc2hvbGQacmVmZXJlbmNlX2dhc19zdXJ2ZXlfcXVvdGUGcmVtb3ZlEXJlcXVlc3RfYWRkX3N0YWtlFXJlcXVlc3RfYWRkX3ZhbGlkYXRvch9yZXF1ZXN0X2FkZF92YWxpZGF0b3JfY2FuZGlkYXRlGHJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvciJyZXF1ZXN0X3JlbW92ZV92YWxpZGF0b3JfY2FuZGlkYXRlG3JlcXVlc3Rfc2V0X2NvbW1pc3Npb25fcmF0ZRZyZXF1ZXN0X3dpdGhkcmF3X3N0YWtlBnNlbmRlchBzZXRfdm90aW5nX3Bvd2VyBHNpemUEc29tZRFzb3J0X3JlbW92YWxfbGlzdAVzcGxpdAVzdGFrZQxzdGFrZV9hbW91bnQMc3Rha2luZ19wb29sD3N0YWtpbmdfcG9vbF9pZBVzdGFraW5nX3Bvb2xfbWFwcGluZ3Mbc3RvcmFnZV9mdW5kX3N0YWtpbmdfcmV3YXJkA3N1aQtzdWlfYWRkcmVzcxZzdWlfc3lzdGVtX3N0YXRlX2lubmVyHXN1bV92b3RpbmdfcG93ZXJfYnlfYWRkcmVzc2VzBXRhYmxlCXRhYmxlX3ZlYxp0YWxseWluZ19ydWxlX2dsb2JhbF9zY29yZRd0YWxseWluZ19ydWxlX3JlcG9ydGVycwt0b3RhbF9zdGFrZRJ0b3RhbF9zdGFrZV9hbW91bnQSdG90YWxfdm90aW5nX3Bvd2VyCnR4X2NvbnRleHQgdW52ZXJpZmllZF9vcGVyYXRpb25fY2FwX2FkZHJlc3MndXBkYXRlX2FuZF9wcm9jZXNzX2xvd19zdGFrZV9kZXBhcnR1cmVzCXZhbGlkYXRvchF2YWxpZGF0b3JfYWRkcmVzcxR2YWxpZGF0b3JfY2FuZGlkYXRlcw12YWxpZGF0b3JfY2FwDXZhbGlkYXRvcl9zZXQWdmFsaWRhdG9yX3N0YWtlX2Ftb3VudBl2YWxpZGF0b3Jfc3Rha2luZ19wb29sX2lkHHZhbGlkYXRvcl90b3RhbF9zdGFrZV9hbW91bnQRdmFsaWRhdG9yX3dyYXBwZXIFdmFsdWUHdmVjX21hcAd2ZWNfc2V0BnZlY3Rvch52ZXJpZmllZF9vcGVyYXRpb25fY2FwX2FkZHJlc3MKdmVyaWZ5X2NhcAx2b3RpbmdfcG93ZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAQECAQICAQMEEBAnAAAAAAAAAAAAAAAAAAADCADKmjsAAAAAAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMICgAAAAAAAAADCAsAAAAAAAAAAwgMAAAAAAAAAAMIDQAAAAAAAAADCGUAAAAAAAAACgMBAAoFAQAAAgmVAQMYCggTaAsNAQgTaQoDiwELDAIICAVOCwwCCAgIFp0BCwwCBQgWHQsPAgUDOggGAQIKOAOcAQV4A4cBAyQDawOMAQNsCBGUAQoFkwEDAgILOAOcAQV4A4cBA6oBAyQDawOMAQNsCBGUAQoFkwEDAwIDOAOcAQWKAQgIBAIEOAOcAQWKAQgIWwEAAwAANjMOABEtDAUKATgADAQOAEE6DAMGAAAAAAAAAAAMAgoCCgMjBB8FEA4ACgJCOgwGDQQKBhF5CwYRejgBCwIGAQAAAAAAAAAWDAIFCwsFCwAKATgCQA4AAAAAAAAAAAsECgE4AwoBOAQ4BQsBEUESAAwHDQcPABGEAQsHAgEDAABDRQoADgEMAy4LAxEUIAQRCgAOAQwELgsEERcgDAUFEwkMBQsFBBYFHAsAAQsCAQcHJw4BEXoMBgoAEAEKBjgGIAQmBSwLAAELAgEHCycOARFxBDAFNgsAAQsCAQcMJwoADwIOARF5CwY4AQsADwEOARF6CwELAhGAATgHAgIDAABHNQoBLhFZDAQKABABCgQ4BgQKBRALAAELAQEHDScKAA8BCwQ4CBGBAQwDDgMRcQQaBSALAAELAQEHDCcOAxF5DAIKAA8CCgI4CQENAwoBLhFYEWwLAA8DCwILAwsBEYABOAoCAwMAAExFCwIuEVkMBwoAEAEKBzgGBAoFDgsAAQcNJwoADwELBzgIEYEBDAYKAA4GDAMuCwMRFCAEJQoADgYMBC4LBBEXIAwFBScJDAULBQQqBS4LAAEHBycOBhFxBDIFNgsAAQcMJw4GEXsLASYEPAVACwABBwonCwAPBAsGOAsCBAMAAAMQCgAQAAoBERYLABAECwERGBYGAQAAAAAAAAAhBA0FDwcHJwIFAwAATiQLAS4RWQwCCgAQAAsCERoMBA4EOAwEDQURCwABBwknDQQ4DQwDCgAQBQ4DOA4gBBsFHwsAAQcQJwsADwULA0QOAgYDAAADFg4COA8HBCYEBgUMCwABCwMBBw8nCwALAREZCwIKAy4RWQsDEXUCBwMAADcrDgERaAwDCgAQAgoDOBAEFgoAEAIOARFoOBEUDAQLAAsEERkLAQsCEXcFKgoAEAMKAzgSBBwFIgsAAQsCAQcIJwsADwMLAzgTEYIBCwELAhF3AggDAAA7CgsCEVkMAwsADwALAxEdCwERdgIJAwAAW24KCC4RWAYBAAAAAAAAABYMDxGFAQwUCgAQAAoUCgEuOA8KAi44DxExDBYMFQoACgMUDAkuCwkRMAwQCgAQAA4QETUMEQoAEAAOEBEcCwQOFQ4WES8MDgwTDA0MEgoAEAALFAsRCxULFgsSCw0LEwsOETIMDAwLCgAPAA4LDgwLAQsCCggRMwoADwARLgoADwAKCBEsCg8KABAADgsODAoDDhAMCi4LChE0CgALDxEqCgAKAwoIEScKAAsFCwYLBwsDCwgRCgoAEAARLQoADwYVCgAPABGEAQsAEQsCCgAAAFxqCgAQAEE6DAcKBwYAAAAAAAAAACQEYwUJCwcGAQAAAAAAAAAXDAcKABAACgdCOgwNCg0RegwMCw0RewwJCgkKASYEKAoAEAcODDgUBCcKAA8HDgw4FQEBBWILCQoCJgRXCgAQBw4MOBQEQAoADwcODDgWDAgKCBQGAQAAAAAAAAAWCggVCwgUDAYFRwoADwcLDAYBAAAAAAAAADgXBgEAAAAAAAAADAYLBgoDJARWCgAPAAoHOBgMCgoACwoKBAkKBREoBWIKAA8ACgc4GAwLCgALCwoECQoFESgFBAsEAQsAAQsFAQILAAAAYhgKABAAQToMAgYAAAAAAAAAAAwBCgEKAiMEFQULCgAPAAoBQzoRbgsBBgEAAAAAAAAAFgwBBQYLAAECDAEAAGM8CwAQAAwKCgpBOgwDQGQAAAAAAAAAAAwBBgAAAAAAAAAADAIKAgoDIwQfBQ8KCgoCQjoMCQ0BCgkRbwsJEXw4GURkCwIGAQAAAAAAAAAWDAIFCgsKAQsBOBoMBAYAAAAAAAAAAAwHEYUBEYMBFwwIBgAAAAAAAAAADAUKBwoIIwQ6BTENBDgbDAYMBQsHCwYWDAcFLAsFAg0BAAADBAsAEAYUAg4BAAADBgsAEAALAREiEXsCDwEAAAMGCwAQAAsBESIReAIQAQAAAwYLABAACwERIhF5AhEBAAADAwsAEAICEgMAAAMMCgAQAEE6CgAQBUEOFwsAEAQ4HBYCEwMAABgICwAQAAsBERoMAg4COAwCFAAAAAMFCwAQAAsBERUCFQMAAAMGCwALAREWBgAAAAAAAAAAJAIWAAAAayEKAEE6DAMGAAAAAAAAAAAMAgYAAAAAAAAAAAwECgIKAyMEGwUMCgAKAkI6CgERcAQWCwQGAQAAAAAAAAAWDAQLAgYBAAAAAAAAABYMAgUHCwABCwEBCwQCFwAAAAMHCwAQBAsBERgGAAAAAAAAAAAkAhgAAABrIQoAOBwMAwYAAAAAAAAAAAwCBgAAAAAAAAAADAQKAgoDIwQbBQwKAAoCOB0KARFwBBYLBAYBAAAAAAAAABYMBAsCBgEAAAAAAAAAFgwCBQcLAAELAQELBAIZAAAAAxAKABABCgE4BgQLCwAPAQsBOB4RggECCwAPAAsBER0CGgAAAGIfCgBBOgwDBgAAAAAAAAAADAIKAgoDIwQbBQoKAAoCQjoRegoBIQQWCwABCwI4HwILAgYBAAAAAAAAABYMAgUFCwABOCACGwAAAGIfCgA4HAwDBgAAAAAAAAAADAIKAgoDIwQbBQoKAAoCOB0RegoBIQQWCwABCwI4HwILAgYBAAAAAAAAABYMAgUFCwABOCACHAAAAHAuCgFBOwwFBgAAAAAAAAAADAMHFAwGCgMKBSMEKAUMCgEKA0I7FAwCCgALAhEaDAQOBDgMBBkFHwsAAQsBAQcJJw0GCwQ4IUQOCwMGAQAAAAAAAAAWDAMFBwsAAQsBAQsGAh0DAABOFgoACwEMAi4LAhEaDAQOBDgMBAsFDwsAAQcJJw0EOA0MAwsACwNDOgIeAAAAcS0KABAACgERGgwFDgU4DAQQDQU4DQwDCwAPAAsDQzoCCgAQBAoBERsMBg4GOAwEIA0GOA0MBAsADwQLBDgiAgsCBCMFJwsAAQcOJwsADwELATgeEYIBAh8DAAADBwsACwERfxQLAhEeAiADAAA7CAsBEVkMAgsACwIJER4CIQMAADsICwERWQwCCwALAggRHgIiAAAAdhMKAAsBERoMAw4DOAwECAUMCwABBwknDQM4DQwCCwALAkI6AiMDAAB3OQoAEAAKAREaDAcOBzgMBAsIDAMFDwoCBwAhDAMLAwQZDQc4DQwFCwAQAAsFQjoCCgAQBAoBERsMCA4IOAwEJAgMBAUoCwIHASEMBAsEBDINCDgNDAYLABAECwY4HQILAA8BCwE4HhGCAS4CJAEAAHYVCgAQAAsBERoMAw4DOAwECQUNCwABBwknDQM4DQwCCwAQAAsCQjoCJQEAAHYVCgAQBAsBERsMAw4DOAwECQUNCwABBxEnDQM4DQwCCwAQBAsCOB0CJgMAAHgnCgERfhQMBgoCBwAhBBALAAsGDAMuCwMRJAwEBRULAAsGCwIRIwwECwQMBwoBOCMMBQsHEXIOBSEEIAUkCwEBBxMnCwERfQInAAAAfCAKAA8FESsKABAFOCQgBBkFCQoADwVFDgwDCgAPAAsDOBgMBAoACwQKAQgKAhEoBQMLAQELAAELAgECKAAAAH46CgQuEVgGAQAAAAAAAAAWDAUOARF6DAYOARF5DAcKAA8CCgc4CQEKABAHDgY4FAQcCgAPBw4GOBUBAQoAEAYUDgERexcKAA8GFQsCCgYRKQoFCwYOARF5CwMSBDglDQELBRFsCwAPAwsHCwELBBGAATgKAikAAACAAUUKAA4BDAIuCwI4JgQMCgAOATgnAQEKAC44KAwHDgdBOwwFBgAAAAAAAAAADAQKBAoFIwRCBRoOBwoEQjsMBgoACgY4KQwICggOAQwDLgsDOCoEOQoIDgE4KwsILjgsBDYKAAsGOCcBAQU4CwYBBT0LCAELBgELBAYBAAAAAAAAABYMBAUVCwABAioAAAA6HAoAEAQ4LSAEGQUGCgAPBDguDAINAgoBEWkKAQ4CEXoOAhF5EgM4LwoADwALAkQ6BQALAAECKwAAAIkBOQoALkEODAYGAQAAAAAAAAAMBAoECgYjBDYFCwoACgQMAS4LAUIOFAwDCgQMBQoFBgAAAAAAAAAAJAQxBRoLBQYBAAAAAAAAABcMBQoACgUMAi4LAkIOFAoDJAQpBSoFMQoACgUKBQYBAAAAAAAAABZHDgUVCwQGAQAAAAAAAAAWDAQFBgsAAQIsAAAAYhoKAC5BOgwDBgAAAAAAAAAADAIKAgoDIwQVBQsKAAoCQzoKARF0CwIGAQAAAAAAAAAWDAIFBgsAAQsBAQItAAAAiwEeBgAAAAAAAAAADAMKAEE6DAIGAAAAAAAAAAAMAQoBCgIjBBoFDAoACgFCOgwECwMLBBF7FgwDCwEGAQAAAAAAAAAWDAEFBwsAAQsDAi4AAABiFwoALkE6DAIGAAAAAAAAAAAMAQoBCgIjBBQFCwoACgFDOhFqCwEGAQAAAAAAAAAWDAEFBgsAAQIvAAAAjAFFBgAAAAAAAAAADAg4MAwEBgAAAAAAAAAADAk4MAwFDQAuOCQgBDwFDg0ARQ4MCgoCCgpCDhQ1CgE1GAcDGgwGDQQKCgoGNDgxCwgLBjQWDAgKAwoKQg4UNQoBNRgHAxoMBw0FCwoKBzQ4MQsJCwc0FgwJBQgLAwELAgELCAsECwkLBQIwAAAAjQEoBxUMBQ4BODIgBCQFBw0BODMMBAwGCgAKBhETBBAFFAsAAQcFJwoAEAAMAwsEODQMAgsDDgIRNRGDASYEIw0FCwZEOwUCCwABCwUCMQAAAJABL0AOAAAAAAAAAAAMB0AOAAAAAAAAAAAMCAoAQToMBQsDCgUaDAkGAAAAAAAAAAAMBAoECgUjBCoFEgoACgRCOhF8NQoCNRgKATUaDAYNBwsGNEQODQgKCUQOCwQGAQAAAAAAAAAWDAQFDQsAAQsHCwgCMgAAAJEBbAsBCwIXDBZADgAAAAAAAAAADAxADgAAAAAAAAAADA4KAEE6DBQKFA4GODUXDBUGAAAAAAAAAAAMEwoTChQjBGcFFwoAChNCOhF8NQwZDgMKE0IOFAwXDgYOEzg2BDAOBg4TODcUDA8LFwsPFwwJBT0KBTULGRgKFjUaDBALFwsQNBYMCQsJDAsNDAsLRA4OBAoTQg4UDBgOCA4TODYEVQ4IDhM4NxQMEQsYCxEXDAoFXQoHChUaDBILGAsSFgwKCwoMDQ0OCw1EDgsTBgEAAAAAAAAAFgwTBRILAAELDAsOAjMAAACSAWkKAC5BOgwHCgcGAAAAAAAAAAAkBAkFFwsAAQsEAQsDAQsFAQsCAQsBAQcSJwYAAAAAAAAAAAwGCgYKByMEXAUeCgAKBkM6DAoKAQoGQg4UDAkKAwoJODgMCAsJNQoKLhFrNRgHAxoMDA0ICww0ODgMDQ0NCgQKAgoGQg4UODg4OQEODTgPBgAAAAAAAAAAJARSCgouEXoMCwoKCw0LCwoFEXUFVAsNODoLCgsIEW0LBgYBAAAAAAAAABYMBgUZCwABCwQBCwMBCwUBCwIBCwEBAjQAAACXAVQKAUE6DAkGAAAAAAAAAAAMCAoICgkjBEkFCgoBCghCOgwMCgwRegwNCgQODTgmBBwKBA4NODsUODQMBgUeBxUMBgsGDAsKBQ4NODwEJwYAAAAAAAAAAAwHBSkGAQAAAAAAAAAMBwsHDAoKAAsNCgwRbwoMEXsKDBF8CgwRawoCCghCDhQKAwoIQg4UCwwKABFzCwsLChICOD0LCAYBAAAAAAAAABYMCAUFCwEBCwMBCwUBCwQBCwIBAjUBAACLASMGAAAAAAAAAAAMBAYAAAAAAAAAAAwCCgFBOwwDCgIKAyMEHQUMCgAKAQoCQjsUESIMBQsECwURfBYMBAsCBgEAAAAAAAAAFgwCBQcLAAELAQELBAI2AQAAAwMLABAAAjcBAAADBQsAEAELATgGAjgBAAADBQsAEAMLATgSAgABAAYABAAFAAIAAwAAAAcAPwCPAQARdmFsaWRhdG9yX3dyYXBwZXLDBKEc6wsGAAAADAEACAIIEAMYMARIBgVONAeCAdMBCNUCQAaVAwoKnwMGDKUDZA2JBAIPiwQCAA4BCgEQAAwAAgQAAQACAAIDDAADAQQAAAUAAQAACAIDAAAGAQQAAAsCBQAADwYHAAIECAkBBAIGCQwBBAIJCgsBBAIPDQcABQQHBAYEAggDBwgBAQgAAQcIAAEHCAMBCAMAAQYIAAEDAwMJAAcIAQEIAgEHCAIBBwkAAQkAAQYIAglUeENvbnRleHQJVmFsaWRhdG9yEFZhbGlkYXRvcldyYXBwZXIJVmVyc2lvbmVkBmNyZWF0ZQljcmVhdGVfdjEHZGVzdHJveQVpbm5lchxsb2FkX3ZhbGlkYXRvcl9tYXliZV91cGdyYWRlDmxvYWRfdmFsdWVfbXV0CnR4X2NvbnRleHQRdXBncmFkZV90b19sYXRlc3QJdmFsaWRhdG9yDXZhbGlkYXRvcl9zZXQRdmFsaWRhdG9yX3dyYXBwZXIHdmVyc2lvbgl2ZXJzaW9uZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAACAQcIAgADAAAFBgYBAAAAAAAAAAsACwE4ABIAAgEDAAAFBgoAEQMLAA8AOAECAgMAAAUGDQARAwsAEwA4AgIDAAAABQoLAC4RBAYBAAAAAAAAACEEBwUJBwAnAgQAAAAFBAsAEAARCAIAAAANABZzdWlfc3lzdGVtX3N0YXRlX2lubmVylUGhHOsLBgAAAAwBAC0CLWgDlQHUBQTpBjIFmwf7BgeWDrwdCNIrYAayLHUKpy29AQzkLsIRDaZALg/UQAQAcAFEAhkCGgIbAicCQwJGAm4CcgJ4AnkCrgECrwEAZABnAGoAoQEAogEApgEADAQAAA0EAAAJBAAACgQAAAsDAAEEBwEAAAIADAADAQQBAAEEAgwBAAEGAwcACAUCAAkODAIHAQQBCw8CAAwUBwIBAAAADRUHAQMADgYEAA8HCAAQCAQAEREEABIQDAASEgIAExMEAAAdAAEAAB4CAwAAoAEBBAAAUAUGAABSBwYAAE8HBgAAUQcGAABUCAYAAGAIBgAAUwkGAABfCQYAAE0KBgAATgsGAABVDAYAAEsNBgAAeg0GAABMDgYAAHsOBgAAVgcGAACXAQ8GAACVAQ8GAACWAQ8GAACfAQ8GAACYAQ8GAACBAQ8GAACaAQ8GAACDAQ8GAACbAQ8GAACEAQ8GAACdAQ8GAACGAQ8GAACcARAGAACFARAGAACeAQ8GAACHAQ8GAACZAQ8GAACCAQ8GAAAXERIAACQTFAAARxMUAABxExQAACwGFAAAJhMUAACnARUUAACoARUWAACpARMXAAAvFRgAADETFAAAMBMUAAApGRIAASBeQAEAATldOwEAAkAjJAADISIGAQADOlEUAQADYlUiAQADrQFTFAEAA7IBUCIBAAOzAQYiAQAEKl82AQAENjYiAQAFIkAGAQMHO1wGAQAKSGAGAQwLJCcUAAtcJygADBw/OwIBAAwjBiACAQAMLT9ZAgEADC5DRAIBAAw1QgYCAQAMSkNJAgEADRxFOwEDDSMGQQEDDTVGBgEDDThIOwEDDUpHBgEDDWFAQQEDDhdUEgAPYzgUABAXVxIAEEASHgAQc1IUABB1UhQAEUApJgARQUoGABFUMgYAEV01BgARXjIGABF8SwYAEX1LBgARfksGABF/SwYAEYABTgYAEYgBSwYAEYkBSwYAEYoBSwYAEYsBSwYAEYwBSwYAEY0BSwYAEY4BSwYAEY8BSwYAEZABSwYAEZEBTgYAEZIBSwYAEZMBSwYAEZQBSwYAErABPT4AExYdLQATF1YGABMYTQYAEx8dFAATMjQxABMzNDEAEzQwMQATNzo7ABNAGxwAE0IdFAATTTcGABNPLAYAE1AqBgATUSsGABNSKwYAE1MzBgATVTkGABNoHRcAE3YdFAATqAE6FgATqgE6FAATsQEvLgBDHzohPCFCH00oRh9FH0goSihMKEsoRx85ITYhOCE3IT1YRB9JKD4hMxQyFDshP1s1IQcKCBILBwEICgMDCAAIDwcIDAEIAggDAwMDAwMDBwgMAQgAAQgDEAcIAwoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgMAAIHCAMHCAwDBwgDBggTAwMHCAMDBwgMBAcIAwsIAQgKBQcIDAUHCAMKCwgBCAoLBQEDBQcIDAMHCAMIEAcIDAMHCAMGCBMFAwgUBQcLDQIFCw4BBQMHCAMKAgYIDAQHCAMKAgoCBggMCwcIAwMDCwcBCAoLBwEICgMDAwMDBwgMAQsHAQgKAQYIAwEDAgYIAwUBCAkBBgsLAggJBQELDgEFAwoLCAEICgsFAQMHCAwCAwgVAgoIEgcIDAEIFQEGCBUBCBECBQsOAQUBCw0CCQAJAQEICgELBwEJAAEHCAwBCAYXAwMDAwMIBggAAwMBCwcBCAoDAwsHAQgKCA8DCAYIEQMDCw0CBQsOAQUDCBUBCBIBBggMAQUQBQoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgMAwcIFQgSBwgMAgcIFQcIDAMHCBUDBwgMAQYKCBIBCBQDBwgVBggTAgMHCBUGCBQBAQcIEgMHCBIIFAMDBwgVAwYIDAIHCBUGCAwCBwgSAwELCAEJAAQHCBUFCwcBCAoHCAwBBggQAwcIFQgQBwgMAgYIFQUBAQQGBQYFBQcLDgEFAQYIFAEGBQIGCw0CCQAJAQYJAAEJAAELDgEJAAMHCw0CCQAJAQkACQECBwsNAgkACQEGCQABBwkBAgYLDgEJAAYJAAIHCw4BCQAJAAIHCw4BCQAGCQABBgsOAQkAAgkACQECBwgSBwgMAgcIEgoCAgcIEgYIEgIGCBUGCBIDBwgSCgIKAiwBAwMDAwMDAQEBCwcBCAoDAwMDAwMDAwQDAwMLBwEICgMDAwsHAQgKCwcBCAoLBwEICgsHAQgKAwMDCwcBCAoECwcBCAoEAwMDAwQDAQcLBwEJAAIHCwcBCQALBwEJAAEGCBEBBgsHAQkAAQcIDwIHCwcBCQADCQcIFQcLBwEICgcLBwEICgcLDQIFCw4BBQMDAwMHCAwGBwgRCwcBCAoLBwEICgsHAQgKAwMBCAQBBgkBBQsHAQgKAwsHAQgKCwgBCAoLBwEICgELCAEICgIHCwgBCQAKCwgBCQABBgsFAQkAAQsFAQkAAgsHAQkABwgMAgkABQNCYWcHQmFsYW5jZQRDb2luAklEBk9wdGlvbgNTVUkMU3Rha2VTdWJzaWR5CVN0YWtlZFN1aQtTdG9yYWdlRnVuZBNTdWlTeXN0ZW1TdGF0ZUlubmVyFVN1aVN5c3RlbVN0YXRlSW5uZXJWMhRTeXN0ZW1FcG9jaEluZm9FdmVudBBTeXN0ZW1QYXJhbWV0ZXJzElN5c3RlbVBhcmFtZXRlcnNWMgVUYWJsZQlUeENvbnRleHQfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAlWYWxpZGF0b3IVVmFsaWRhdG9yT3BlcmF0aW9uQ2FwDFZhbGlkYXRvclNldAZWZWNNYXAGVmVjU2V0EWFjdGl2ZV92YWxpZGF0b3JzDWFkdmFuY2VfZXBvY2gmYXNzZXJ0X25vX3BlbmRpbmdfb3JfYWN0aXZlX2R1cGxpY2F0ZXMDYmFnB2JhbGFuY2UEY29pbghjb250YWlucwZjcmVhdGUYY3JlYXRlX3N5c3RlbV9wYXJhbWV0ZXJzGmRlcml2ZV9yZWZlcmVuY2VfZ2FzX3ByaWNlDGRlc3Ryb3lfc29tZQxkZXN0cm95X3plcm8EZW1pdAVlbXB0eQVlcG9jaBFlcG9jaF9kdXJhdGlvbl9tcxhlcG9jaF9zdGFydF90aW1lc3RhbXBfbXMFZXZlbnQMZXh0cmFfZmllbGRzFGV4dHJhY3RfY29pbl9iYWxhbmNlDGZyb21fYmFsYW5jZQdnZW5lc2lzHGdlbmVzaXNfc3lzdGVtX3N0YXRlX3ZlcnNpb24DZ2V0B2dldF9tdXQQZ2V0X3JlcG9ydGVyc19vZh9nZXRfc3RvcmFnZV9mdW5kX29iamVjdF9yZWJhdGVzHmdldF9zdG9yYWdlX2Z1bmRfdG90YWxfYmFsYW5jZRpnZXRfdmFsaWRhdG9yX211dF93aXRoX2N0eC9nZXRfdmFsaWRhdG9yX211dF93aXRoX2N0eF9pbmNsdWRpbmdfY2FuZGlkYXRlcyNnZXRfdmFsaWRhdG9yX211dF93aXRoX3ZlcmlmaWVkX2NhcAZpbnNlcnQMaW50b19iYWxhbmNlImlzX2FjdGl2ZV92YWxpZGF0b3JfYnlfc3VpX2FkZHJlc3MIaXNfZW1wdHkHaXNfc29tZQRqb2luCGpvaW5fdmVjHGxlZnRvdmVyX3N0b3JhZ2VfZnVuZF9pbmZsb3cTbWF4X3ZhbGlkYXRvcl9jb3VudBNtaW5fdmFsaWRhdG9yX2NvdW50G21pbl92YWxpZGF0b3Jfam9pbmluZ19zdGFrZQNuZXczbmV3X3VudmVyaWZpZWRfdmFsaWRhdG9yX29wZXJhdGlvbl9jYXBfYW5kX3RyYW5zZmVyGm5leHRfZXBvY2hfdmFsaWRhdG9yX2NvdW50Bm9iamVjdAZvcHRpb24KcGFyYW1ldGVycwNwYXkQcHJvdG9jb2xfdmVyc2lvbg9wdWJsaWNfdHJhbnNmZXITcmVmZXJlbmNlX2dhc19wcmljZQZyZW1vdmUQcmVwb3J0X3ZhbGlkYXRvchVyZXBvcnRfdmFsaWRhdG9yX2ltcGwRcmVxdWVzdF9hZGRfc3Rha2UacmVxdWVzdF9hZGRfc3Rha2VfbXVsX2NvaW4VcmVxdWVzdF9hZGRfdmFsaWRhdG9yH3JlcXVlc3RfYWRkX3ZhbGlkYXRvcl9jYW5kaWRhdGUYcmVxdWVzdF9yZW1vdmVfdmFsaWRhdG9yInJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvcl9jYW5kaWRhdGUbcmVxdWVzdF9zZXRfY29tbWlzc2lvbl9yYXRlFXJlcXVlc3Rfc2V0X2dhc19wcmljZRZyZXF1ZXN0X3dpdGhkcmF3X3N0YWtlFHJvdGF0ZV9vcGVyYXRpb25fY2FwCXNhZmVfbW9kZR1zYWZlX21vZGVfY29tcHV0YXRpb25fcmV3YXJkcyRzYWZlX21vZGVfbm9uX3JlZnVuZGFibGVfc3RvcmFnZV9mZWUZc2FmZV9tb2RlX3N0b3JhZ2VfcmViYXRlcxlzYWZlX21vZGVfc3RvcmFnZV9yZXdhcmRzBnNlbmRlch1zZXRfY2FuZGlkYXRlX2NvbW1pc3Npb25fcmF0ZRdzZXRfY2FuZGlkYXRlX2dhc19wcmljZSdzZXRfY2FuZGlkYXRlX3ZhbGlkYXRvcl9jb21taXNzaW9uX3JhdGUhc2V0X2NhbmRpZGF0ZV92YWxpZGF0b3JfZ2FzX3ByaWNlCXNpbmdsZXRvbgVzcGxpdBZzdGFrZV9hY3RpdmF0aW9uX2Vwb2NoDXN0YWtlX3N1YnNpZHkUc3Rha2Vfc3Vic2lkeV9hbW91bnQZc3Rha2Vfc3Vic2lkeV9zdGFydF9lcG9jaAxzdGFraW5nX3Bvb2wVc3Rha2luZ19wb29sX21hcHBpbmdzDnN0b3JhZ2VfY2hhcmdlDHN0b3JhZ2VfZnVuZBRzdG9yYWdlX2Z1bmRfYmFsYW5jZRlzdG9yYWdlX2Z1bmRfcmVpbnZlc3RtZW50DnN0b3JhZ2VfcmViYXRlA3N1aQpzdWlfc3lzdGVtFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIUc3lzdGVtX3N0YXRlX3ZlcnNpb24FdGFibGUNdG90YWxfYmFsYW5jZQ50b3RhbF9nYXNfZmVlcxx0b3RhbF9vYmplY3Rfc3RvcmFnZV9yZWJhdGVzC3RvdGFsX3N0YWtlH3RvdGFsX3N0YWtlX3Jld2FyZHNfZGlzdHJpYnV0ZWQIdHJhbnNmZXIKdHhfY29udGV4dBV1bmRvX3JlcG9ydF92YWxpZGF0b3IadW5kb19yZXBvcnRfdmFsaWRhdG9yX2ltcGwgdXBkYXRlX2NhbmRpZGF0ZV9uZXR3b3JrX2FkZHJlc3MfdXBkYXRlX2NhbmRpZGF0ZV9uZXR3b3JrX3B1YmtleRx1cGRhdGVfY2FuZGlkYXRlX3AycF9hZGRyZXNzIHVwZGF0ZV9jYW5kaWRhdGVfcHJpbWFyeV9hZGRyZXNzIHVwZGF0ZV9jYW5kaWRhdGVfcHJvdG9jb2xfcHVia2V5KnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX25ldHdvcmtfYWRkcmVzcyl1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9uZXR3b3JrX3B1YmtleSZ1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wMnBfYWRkcmVzcyp1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wcmltYXJ5X2FkZHJlc3MqdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcHJvdG9jb2xfcHVia2V5KXVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3dvcmtlcl9hZGRyZXNzKHVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3dvcmtlcl9wdWJrZXkfdXBkYXRlX2NhbmRpZGF0ZV93b3JrZXJfYWRkcmVzcx51cGRhdGVfY2FuZGlkYXRlX3dvcmtlcl9wdWJrZXkSdXBkYXRlX2Rlc2NyaXB0aW9uEHVwZGF0ZV9pbWFnZV91cmwLdXBkYXRlX25hbWUhdXBkYXRlX25leHRfZXBvY2hfbmV0d29ya19hZGRyZXNzIHVwZGF0ZV9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5HXVwZGF0ZV9uZXh0X2Vwb2NoX3AycF9hZGRyZXNzIXVwZGF0ZV9uZXh0X2Vwb2NoX3ByaW1hcnlfYWRkcmVzcyF1cGRhdGVfbmV4dF9lcG9jaF9wcm90b2NvbF9wdWJrZXkgdXBkYXRlX25leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MfdXBkYXRlX25leHRfZXBvY2hfd29ya2VyX3B1YmtleRJ1cGRhdGVfcHJvamVjdF91cmwcdXBkYXRlX3ZhbGlkYXRvcl9kZXNjcmlwdGlvbhp1cGRhdGVfdmFsaWRhdG9yX2ltYWdlX3VybBV1cGRhdGVfdmFsaWRhdG9yX25hbWUrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX25ldHdvcmtfYWRkcmVzcyp1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfbmV0d29ya19wdWJrZXkndXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3AycF9hZGRyZXNzK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wcmltYXJ5X2FkZHJlc3MrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleSp1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MpdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3dvcmtlcl9wdWJrZXkcdXBkYXRlX3ZhbGlkYXRvcl9wcm9qZWN0X3VybAh2MV90b192Mgl2YWxpZGF0b3INdmFsaWRhdG9yX2NhcCB2YWxpZGF0b3JfbG93X3N0YWtlX2dyYWNlX3BlcmlvZB12YWxpZGF0b3JfbG93X3N0YWtlX3RocmVzaG9sZBh2YWxpZGF0b3JfcmVwb3J0X3JlY29yZHMNdmFsaWRhdG9yX3NldBZ2YWxpZGF0b3Jfc3Rha2VfYW1vdW50GXZhbGlkYXRvcl9zdGFraW5nX3Bvb2xfaWQfdmFsaWRhdG9yX3N0YWtpbmdfcG9vbF9tYXBwaW5ncxx2YWxpZGF0b3JfdG90YWxfc3Rha2VfYW1vdW50InZhbGlkYXRvcl92ZXJ5X2xvd19zdGFrZV90aHJlc2hvbGQKdmFsaWRhdG9ycwV2YWx1ZQd2ZWNfbWFwB3ZlY19zZXQedmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzCnZlcmlmeV9jYXAMd2l0aGRyYXdfYWxsBHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAQECAQICAQMDCAEAAAAAAAAAAwgAAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAMIBQAAAAAAAAADCAYAAAAAAAAAAwgHAAAAAAAAAAMICAAAAAAAAAAEEBAnAAAAAAAAAAAAAAAAAAAAAgglA2YDPQM/A6QBA6sBA6MBAygIBgECCSUDZgM+Az0DPwOkAQOrAQOjAQMoCAYCAhAkA0cDcQOsAQgVaggRRQgASQOlAQsNAgULDgEFZAgPVwFbCwcBCApYCwcBCApaA1kDJgMoCAYDAhAkA0cDcQOsAQgVaggRRQgBSQOlAQsNAgULDgEFZAgPVwFbCwcBCApYCwcBCApaA1kDJgMoCAYEAgwkA0cDSQN2A2wDaQNtA2sDZQN0A3cDPAMAAwAAGhsLAAoGEXQMCA4IEW8MBwYAAAAAAAAAAAsCESkLCAsBEVELBAsHOAALBQk4ATgBBgAAAAAAAAAABgAAAAAAAAAACwMLBhE0EgICAQMAAAYLCwALAQsCCwMLBAsFCwYLBxE0EgACAgMAACU3CwATAgwRDAMMDAwNDAsMDgwKDA8MFQwJDAcMEgwXAQwIDAELBxMADAYMEwwWDBQMBQwEDBAMAgsBCwgGAgAAAAAAAAALFwsSCwILEAYEAAAAAAAAAAsECwULFAsWCxMLBhIBCwkLFQsPCwoLDgsLCw0LDAsDCxESAwIDAwAAJhoKDy4RQQsBCwILAwsECwULBgsHCwgLCQsKCwsLDAsNCw4KDxFUDBALAA8ACxALDxF4AgQDAAAGBQsADwALARF6AgUDAAAGGQoAEAARdQoAEAEQAhQjBAoFEAsAAQsBAQcDJwoADwALABABEAMUCwERdwIGAwAABh8KABAAEWxBJgoAEAEQBBQmBBoKABAAEXUKABABEAQUJAQUBRoLAAELAQEHAycLAA8ACwEReQIHAwAALg8KAA8ACwEHARGBAQwDCwAPAA4DCRFyCwMLAhFWAggDAAAuDwoADwALAQcCEYEBDAMLAA8ADgMIEXILAwsCEVgCCQMAAAYHCwAPAAsBCwIuEXsCCgMAAAYICwAPAAsCLhFxCwERVwILAwAABggLAA8ACwILATgCCwMRdgIMAwAAEgwLAQsCCgQRMQwFCwAPAAsDCwULBBF2Ag0DAAAGFA4BEU8KAi4RQCUECAUOCwABCwIBBwknCwAPAAsBCwIRfAIOAwAABhYKABAACgIRcwQGBQwLAAELAQEHBCcKAA8ACwEHABGBAQsCCwAPBREQAg8DAAAGCgoADwALAQcAEYEBCwILAA8FERECEAAAADwuDgARaxQMBQoFCgEiBAkFDQsCAQcGJwoCDgEMAy4LAzgDIAQbCwILAQsFOAQ4BQUtCwIOATgGDAYKBg4FDAQuCwQ4ByAEKwsGCwU4CAUtCwYBAhEAAAA8MgoCDgEMAy4LAzgDBAgFDAsCAQcHJwoCDgE4BgwGDgARaxQMBQoGDgUMBC4LBDgHBBwFIgsCAQsGAQcHJwoGDgU4CQsGLjgKBC8LAg4BOAsBAQUxCwIBAhIDAAAGCAsADwAKAS4RcQsBEVUCEwMAAAYHCwAPAAsCEXELARFiAhQDAAAGBwsADwALAhFxCwERYAIVAwAABgcLAA8ACwIRcQsBEWECFgMAAAYHCwAPAAsCEXELARFqAhcDAABMEAoADwALAhFwDAMKAwsBEWMLAy4MBAsAEAALBBFuAhgDAAAGBwsADwALAhFxCwERWQIZAwAATBAKAA8ACwIRcAwDCgMLARFlCwMuDAQLABAACwQRbgIaAwAABgcLAA8ACwIRcQsBEVsCGwMAAAYHCwAPAAsCEXALARFmAhwDAAAGBwsADwALAhFxCwERXAIdAwAABgcLAA8ACwIRcAsBEWgCHgMAAAYHCwAPAAsCEXELARFeAh8DAABMEQoADwALAxFwDAQKBAsBCwIRZwsELgwFCwAQAAsFEW4CIAMAAAYICwAPAAsDEXELAQsCEV0CIQMAAEwQCgAPAAsCEXAMAwoDCwERaQsDLgwECwAQAAsEEW4CIgMAAAYHCwAPAAsCEXELARFfAiMDAABMEAoADwALAhFwDAMKAwsBEWQLAy4MBAsAEAALBBFuAiQDAAAGBwsADwALAhFxCwERWgIlAwAAT9ACCgAQBhQMJQoJCgAPBhUHDDQMHAoHChwlBBQKCAscJQwLBRYJDAsLCwQZBR8LAAELCgEHCCcKAA8HOAwMKA0DCyg4DQEKAA8IOAwMJw0ECyc4DQELBQoAEAkUFgwFBgAAAAAAAAAACgAPCRULBgoAEAoUFgwGBgAAAAAAAAAACgAPChUKABAAEX4MNgoAEAsRUgwsCiwLNhYMNA4DOA4MKw4EOA4MHQoKLhFACgAQARAMFCYEaAsJCyUKABABEA0UFiYMFAVqCQwUCxQEcQoADw4RTgwVBXM4AQwVCxUMKQ4pOA4MKg0ECyk4DQELNDUMNQodNQweCyw1Cx4YCzUaDDANBAowNDgPDC8LMAsHNRgHDBoMLg0vCi40OA8MLQoAEA8UBgEAAAAAAAAAFgoADw8VCwEKABAPFCEEqQEFrwELAAELCgEHCycOBDgODCAOLzgODDIKAA8ADQQNLwoADwULCAoAEAEQEBQKABABEBEUCgAQARASFAsKEW0KABAAEX4MJA4EOA4MHw4vOA4MMQsgCx8XDCELMgsxFwwzCwIKAA8TFQoAEAARbwoADxQVCy8MIg0iCwQ4DQEOIjgODCMKAA8LCwMLLQsiCgULBhFQDCYKABAPFAwWCgAQExQMFwoAEBQUDBgLJAwZCysMGgsuNAwbCwUMDAoAEAsRUgwNCyoMDgsdDA8LIQszFgwQCyMMEQsWCxcLGAsZCxsLGgsMCw0LDgsPCxALERIEOBAJCgAPFRUKABAJFAYAAAAAAAAAACEEugIKABAHOA4GAAAAAAAAAAAhDBIFvAIJDBILEgTFAgsAEAg4DgYAAAAAAAAAACEMEwXJAgsAAQkMEwsTBMwCBc4CBwonCyYCJgMAAAYECwAQDxQCJwMAAAYECwAQExQCKAMAAAYECwAQFhQCKQMAAAYCBwMCKgMAAAYECwAQBhQCKwMAAAYFCwAQAAsBEYABAiwDAAAGBQsAEAALARF/Ai0DAAAGBAsAEAARfQIuAwAAGBIKABAFDgE4AwQMCwAQBQ4BOBEUDAIFEAsAATgSDAILAgIvAwAABgQLABALEVICMAMAAAYECwAQCxFTAjEAAABaLQ0ARVsMBg0GCwA4EwsGOAIMBw4BOBQEJwsBOBUMBA0HCwQ4DwwFDgc4DgYAAAAAAAAAACQEIAsHCgI4FgsCLhFBOBcFJAsCAQsHOBgLBQwDBSsLAgELBwwDCwMCAwMDBQEDAQQBAgMHAw4DCgMLAwwDDQMEAQEBAAMIAwABBQEGAQcDAQMGAwkDAgArAG8AHQ12YWxpZGF0b3JfY2FwH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3JfY2FwFVZhbGlkYXRvck9wZXJhdGlvbkNhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbAtTdGFraW5nUG9vbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbBVQb29sVG9rZW5FeGNoYW5nZVJhdGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wJU3Rha2VkU3VpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJdmFsaWRhdG9yEVZhbGlkYXRvck1ldGFkYXRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJdmFsaWRhdG9yCVZhbGlkYXRvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCXZhbGlkYXRvchNTdGFraW5nUmVxdWVzdEV2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJdmFsaWRhdG9yFVVuc3Rha2luZ1JlcXVlc3RFdmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHZvdGluZ19wb3dlcg9Wb3RpbmdQb3dlckluZm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwx2b3RpbmdfcG93ZXIRVm90aW5nUG93ZXJJbmZvVjIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxF2YWxpZGF0b3Jfd3JhcHBlchBWYWxpZGF0b3JXcmFwcGVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX3NldAxWYWxpZGF0b3JTZXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0F1ZhbGlkYXRvckVwb2NoSW5mb0V2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX3NldBlWYWxpZGF0b3JFcG9jaEluZm9FdmVudFYyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX3NldBJWYWxpZGF0b3JKb2luRXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0E1ZhbGlkYXRvckxlYXZlRXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdG9yYWdlX2Z1bmQLU3RvcmFnZUZ1bmQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw1zdGFrZV9zdWJzaWR5DFN0YWtlU3Vic2lkeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIQU3lzdGVtUGFyYW1ldGVycwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXISU3lzdGVtUGFyYW1ldGVyc1YyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchNTdWlTeXN0ZW1TdGF0ZUlubmVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchVTdWlTeXN0ZW1TdGF0ZUlubmVyVjIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxZzdWlfc3lzdGVtX3N0YXRlX2lubmVyFFN5c3RlbUVwb2NoSW5mb0V2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMKc3VpX3N5c3RlbQ5TdWlTeXN0ZW1TdGF0ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADB2dlbmVzaXMYR2VuZXNpc1ZhbGlkYXRvck1ldGFkYXRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMHZ2VuZXNpcxZHZW5lc2lzQ2hhaW5QYXJhbWV0ZXJzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMHZ2VuZXNpcxlUb2tlbkRpc3RyaWJ1dGlvblNjaGVkdWxlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMHZ2VuZXNpcw9Ub2tlbkFsbG9jYXRpb24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQAAAAAAAAADIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCnN1aV9zeXN0ZW0OU3VpU3lzdGVtU3RhdGUAAAEAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAQAAAAAAAAACAQAAAAAAAAAgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFY2xvY2sFQ2xvY2sAAAEAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAACAQAAAAAAAAAgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QEAAAAAAAAABARjbG9ik0mhHOsLBgAAAA0BACMCI3YDmQG5BATSBbYBBYgH5QkH7RCnDgiUH2AG9B+dAgqRIrABC8EjCAzJI78kDYhILA60SBwAKwAzADQAWgFnAYQBAhoCLAItAj4CUgJlAnoCfQKCAQKDAQAOBwAADAcCAAEAAQAKBwIAAQABAAsHAgABAAEACQYAABEEAAANCAIAAQABAQQEAQQAAgAMAAIFDAEAAQQIBwEAAAUTBwAGAQQBAAEHAggACAMMAQABCgcMAgcABAELBgcACxQEAAwPAgANEAwCBwEEAQ8SAgAAOgABAAAvAgMAADEEAQIAAAAwBQECAAAANwYBAgAAADgHAQIAAACJAQgJAgAAAIsBCAoCAAAAewsMAgAAAHwNDAIAAABZDg8CAAAAWA4PAgAAAFcQDwIAAABsERICAAAASxMUAgAAAGsVFgIAAABpFBcAAD0YAQIAAAAqGQECAAAAdxobAgAAACkcAQIAAAAiHQECAAAAUx4fAgAAABYeIAIAAABHISICAAAARiEiAgAAAEUjFAIAAABIJCUCAAABJVQ6AQQBJlQ6AQQBKEZHAQQBQFQUAQQBQVRNAQQBTFsUAQQBT0QXAQQBW0RFAQQBXERFAQQBYAIwAQQBZFRFAQQBblRFAQQBdkYqAQQCFWEUAQACFmFFAQACNVo0AQACNkw0AQACSjwBAQACVFoBAQACXQIDAAJgAjMBAAKGAUwBAQACigE9CQEAAowBPQkBAAM7RU0AA15FFAADX0VNAAQkSToBAARQSRcBAAVEASsBAAZRTxQBAAZ5TjQBAAaIAUEUAQAGjQEBNAEAB4ABQBQACEJCCQEACE0JNAEACFFYAQEACIgBORQBAAk8KgEBAwoZSEkCBwQKJEpLAgcECidTUgIHBAouShcCBwQKOSgBAgcECkNISQIHBApPSBcCBwQKYAIoAgcECmFKSQIHBApwXAECBwQKdVMsAgcEC0k6OwEIC2ACLQALhQEuLwANF18BAgcEDSReSwIHBA0nUVICBwQNLl4XAgcEDWACMgIHBA54KgEBCEgnOSo5LCUAVjEwKjAsPSo9LFc2QzdCOEA4AjVPA0AqLSpALC0sMiozLEIsDTUKNTwqPyo/LCIAJAAeAEknNxRKJ0UnMSosKjsqOio7LENQTCc4FFQxTkVOJ0YnJgAoACAAETUjADEsLCw6LCcACzVBKkIqDDVBLC4sLipLJyEATSdDXVUxS0VSMU1FKSwrLDwsKyoONUNiR0VFRRM1HABHJ0pFREVTMUlFHQBMRSoqKiwfABo1AQgFAAEHCBQBCAgGAwMDAwsMAQgSBwgUBAMDCw4BCBIHCBQDBwsGAgkACQELDgEJAAYICAMHCwYCCQAJAQsOAQkBBggIBAcLBgIJAAkBAwYICAcIFAELDgEJAAELDgEJAQYHCwYCCQAJAQMLDgEJAAsOAQkBBggNBwgUAwsOAQkACw4BCQEDBQcLBgIJAAkBAwYIDQsOAQkBBwgUBQcLBgIJAAkBAwMDCwwBCQECCwwBCQALDAEJAQQHCwYCCQAJAQMDCwwBCQAHBwsGAgkACQEDAQsOAQkACw4BCQEGCA0HCBQCCw4BCQALDgEJAQcHCwYCCQAJAQMDAQMGCAgHCBQBAwkHCwYCCQAJAQMDAQMCBggNBggIBwgUBAMDAQMBAQIIEAYIBAMHCwYCCQAJAQMGCAgFBwsHAQgFBwsPAgMDAwMIEAEIBAIHCwYCCQAJAQYICAMHCwYCCQAJAQoDBggIAgYLBgIJAAkBBggIAQoIBAQDAwMDBAYLBgIJAAkBAwMGCA0CCgMKAwMGCwcBCAUDAwMGCwYCCQAJAQMGCAgBBggEAQsPAgMIBAIDCAQBCw8CCQAJAQQICwgQCBEICwEJAAEICwEJAQEIEQEGCBEBBggQAQsHAQkAAggQCw8CAwMBCxMCCQAJAQELCQEJAAELDAEJAAIJAAkBAQsGAgkACQEBCAABCBIBBgsOAQkAAQYJAAEIEAMHCwkBCQAIEAsMAQkABAcLCQEJAAMGCAgHCBQEAwsOAQkACw4BCQEDAwsMAQkACwwBCQEDAQYIDQEGCwwBCQACCwwBCQAHCBQaAQMBAwMHCwcBCAULDAEJAAMDCwwBCQADBggEBwgEAwMGCwoBAwMDCwwBCQEBAwsMAQkAAwMHCAUDAQYLBwEJAAIDAwIHCwcBCQADAQcJAAEGCw8CCQAJAQEGCwoBCQACBgsPAgkACQEJAAEGCQEDBwsJAQkACBADAgEDAgcLDAEJAAMCBwsMAQkACwwBCQABCwMCCQAJAQIHCxMCCQAJAQkAAQcJAQIHCw8CCQAJAQkAAgYLBwEJAAMaAQMBAwMHCwcBCAULDAEJAAMDCwwBCQADBggEBwgEAwYLCgEDAwMIEAsMAQkBAQMDCwwBCQADBwgFAxsBAwEDAwcLBwEIBQsMAQkAAwMLDAEJAQMGCAQHCAQDAwYLCgEDAwMIEAsMAQkBAQMDCwwBCQEDBwgFAwMLDAEJAAsMAQkBCwwBCQECBwsOAQkACw4BCQAHAwcLBwEIBQgEAwMDCBADBwsJAQkABggIAwMHCwcBCQADCQADBwsPAgkACQEJAAkBAQsBAgkACQECBgsTAgkACQEJAAMHCxMCCQAJAQkACQELCwwBCQALDAEJAAsMAQkAAwMLDAEJAQsMAQkBCwwBCQEDAwgQAgYLCQEJAAgQAQsCAgkACQELAwMGCwcBCAUHCwcBCAUDAQgEAwMIEAcLDwIDAwMDBwgFCAQNAwcLBwEIBQMDAQcLBwEIBQgEAwMIEAMIEAcLDwIDAxIGCwcBCAUDAwYLBwEIBQcLBwEIBQMDAQMDAwgEAwgQAwMIEAcLDwIDAwcGCAUKCAQGCAQGCwoBAwMIEAYLDwIDAwUDAwMDCBAGAwoDAwMDCgMEAwYIBAYLCgEDBgsPAgMIBAMGCwcBCAUDCBAKQWNjb3VudENhcAdCYWxhbmNlBUNsb2NrBENvaW4LQ3JpdGJpdFRyZWUJQ3VzdG9kaWFuAklEC0xpbmtlZFRhYmxlBk9wdGlvbgVPcmRlcg1PcmRlckNhbmNlbGVkC09yZGVyRmlsbGVkC09yZGVyUGxhY2VkBFBvb2wLUG9vbENyZWF0ZWQDU1VJBVRhYmxlCVRpY2tMZXZlbAlUeENvbnRleHQIVHlwZU5hbWUDVUlEGWFjY291bnRfYXZhaWxhYmxlX2JhbGFuY2UPYWNjb3VudF9iYWxhbmNlA2FkZARhc2tzBGJhY2sHYmFsYW5jZQpiYXNlX2Fzc2V0HGJhc2VfYXNzZXRfcXVhbnRpdHlfY2FuY2VsZWQaYmFzZV9hc3NldF9xdWFudGl0eV9maWxsZWQaYmFzZV9hc3NldF9xdWFudGl0eV9wbGFjZWQdYmFzZV9hc3NldF9xdWFudGl0eV9yZW1haW5pbmcXYmFzZV9hc3NldF90cmFkaW5nX2ZlZXMOYmFzZV9jdXN0b2RpYW4SYmF0Y2hfY2FuY2VsX29yZGVyBGJpZHMGYm9ycm93FGJvcnJvd19sZWFmX2J5X2luZGV4EmJvcnJvd19sZWFmX2J5X2tleQpib3Jyb3dfbXV0GGJvcnJvd19tdXRfbGVhZl9ieV9pbmRleBFjYW5jZWxfYWxsX29yZGVycwxjYW5jZWxfb3JkZXIEY2xvYgVjbG9jawRjb2luCGNvbnRhaW5zDmNyZWF0ZV9hY2NvdW50C2NyZWF0ZV9wb29sDGNyZWF0ZV9wb29sXwxjcmVhdGlvbl9mZWUHY3JpdGJpdAljdXN0b2RpYW4fZGVjcmVhc2VfdXNlcl9hdmFpbGFibGVfYmFsYW5jZRxkZWNyZWFzZV91c2VyX2xvY2tlZF9iYWxhbmNlDGRlcG9zaXRfYmFzZQ1kZXBvc2l0X3F1b3RlDWRlc3Ryb3lfZW1wdHkTZGVzdHJveV9lbXB0eV9sZXZlbAlkaXZfcm91bmQEZW1pdBNlbWl0X29yZGVyX2NhbmNlbGVkBWV2ZW50EGV4cGlyZV90aW1lc3RhbXAQZmluZF9jbG9zZXN0X2tleQlmaW5kX2xlYWYMZnJvbV9iYWxhbmNlBWZyb250A2dldBZnZXRfbGV2ZWwyX2Jvb2tfc3RhdHVzH2dldF9sZXZlbDJfYm9va19zdGF0dXNfYXNrX3NpZGUfZ2V0X2xldmVsMl9ib29rX3N0YXR1c19iaWRfc2lkZRBnZXRfb3JkZXJfc3RhdHVzAmlkH2luY3JlYXNlX3VzZXJfYXZhaWxhYmxlX2JhbGFuY2USaW5qZWN0X2xpbWl0X29yZGVyC2luc2VydF9sZWFmDGludG9fYmFsYW5jZQZpc19iaWQIaXNfZW1wdHkHaXNfbm9uZQRqb2luDGxpbmtlZF90YWJsZRBsaXN0X29wZW5fb3JkZXJzDGxvY2tfYmFsYW5jZQhsb3Rfc2l6ZRFtYWtlcl9yZWJhdGVfcmF0ZQltYXRjaF9hc2sJbWF0Y2hfYmlkHW1hdGNoX2JpZF93aXRoX3F1b3RlX3F1YW50aXR5BG1hdGgIbWF4X2xlYWYIbWluX2xlYWYQbWludF9hY2NvdW50X2NhcANtdWwJbXVsX3JvdW5kA25ldwRuZXh0EW5leHRfYXNrX29yZGVyX2lkEW5leHRfYmlkX29yZGVyX2lkCW5leHRfbGVhZgZvYmplY3QLb3Blbl9vcmRlcnMGb3B0aW9uCG9yZGVyX2lkDG9yZGVyX2lzX2JpZAVvd25lchFwbGFjZV9saW1pdF9vcmRlchJwbGFjZV9tYXJrZXRfb3JkZXIHcG9vbF9pZA1wcmV2aW91c19sZWFmBXByaWNlCXB1c2hfYmFjawhxdWFudGl0eQtxdW90ZV9hc3NldBhxdW90ZV9hc3NldF90cmFkaW5nX2ZlZXMPcXVvdGVfY3VzdG9kaWFuBnJlbW92ZRRyZW1vdmVfbGVhZl9ieV9pbmRleAxyZW1vdmVfb3JkZXIMc2hhcmVfb2JqZWN0BXNwbGl0A3N1aRlzd2FwX2V4YWN0X2Jhc2VfZm9yX3F1b3RlGXN3YXBfZXhhY3RfcXVvdGVfZm9yX2Jhc2UFdGFibGUOdGFrZXJfZmVlX3JhdGUJdGlja19zaXplDHRpbWVzdGFtcF9tcw50b3RhbF9xdWFudGl0eQh0cmFuc2Zlcgp0eF9jb250ZXh0CXR5cGVfbmFtZQx1aWRfYXNfaW5uZXIOdW5sb2NrX2JhbGFuY2UPdXNyX29wZW5fb3JkZXJzBXZhbHVlDXdpdGhkcmF3X2Jhc2UTd2l0aGRyYXdfYmFzZV9hc3NldA53aXRoZHJhd19xdW90ZRR3aXRoZHJhd19xdW90ZV9hc3NldAR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAMIBQAAAAAAAAADCAYAAAAAAAAAAwgHAAAAAAAAAAMICAAAAAAAAAADCAkAAAAAAAAAAwgKAAAAAAAAAAMICwAAAAAAAAADCAwAAAAAAAAAAwgNAAAAAAAAAAMIDwAAAAAAAAADCBAAAAAAAAAAAwgRAAAAAAAAAAMIEgAAAAAAAAADCBMAAAAAAAAAAwgUAAAAAAAAAAMIFQAAAAAAAAADCBYAAAAAAAAAAgEEAgEAAgEBAgECAgEDAwgAAAAAAAAAAAMIAAAAAAAAAIADCEBLTAAAAAAAAwigJSYAAAAAAAMIAOh2SBcAAAADCADKmjsAAAAAAAIHbQgQGwgLcggLfgNWA38DVQMBAgZtCBBoA04BaggQHgNvAwICBm0IEGgDTgFqCBAcA28DAwIIbQgQaANOAWoIEIEBAx0DHwNvAwQCBmgDbwNxA04BaggQPwMFAgJvA2YLDwIDCAQGAg9JCBEjCwcBCAUYCwcBCAVjA2IDhwELEwIIEAsPAgMDfgNWA38DVQMhCwkBCQB0CwkBCQEyCwwBCBIgCwwBCQBzCwwBCQEGNQM1ATUCNQAAAAAmBwsAEwUMAQELATgAAgEBAAABAwsAES8CAgAAACk9OAEMBjgCDAkKBgoJIgQJBQ0LBQEHDycKAAoBJgQSBRYLBQEHAScKBRFQDAgOCBFRFAwHCwgKBTgDCgU4AwcaBxsKBTgECgAKAQoCCgMKBTgFCwU4BgsEOAc4CDkAOAkLBwsGCwkLAAsBCwILAxIAOAoCAwEAAAETDgI4CwceIQQGBQoLAwEHEycHHAcdCwALAQsCOAwLAzgNAgQBAAABCAsANgALAjgOCwE4DzgQAgUBAAABCAsANgELAjgOCwE4ETgSAgYBAAABBwsANgALAQsCCwM4EwIHAQAAAQcLADYBCwELAgsDOBQCCAEAAD4WDgM4FQwGCwALAQkLAgsDCwQLBTgWDAgMBw4IOBUMCQsHCwgLCQsGFwIJAQAAPxULAAsBBxsLAhE+CwM4ETgXDAYMBQ4FOBgMBwsFCgQ4GQsGCwQ4GgsHAgoAAABDrQILAQwbOAcMCwsEDBcKADYCDAoKCi44GwQUCwABCwoBCwsLFwIKCi44HAwcDB4KCi44GyAEJAUfCh4KAiUMBQUmCQwFCwUEqgIKCgocOB0MHQodEAM4HjgfFAwWCh0QAzggIASIAgU4Ch0QAwoWOCEMEAoQEAQUDA8JDBgKEBAFFAoDJQRVCAwYCgA2AAoQEAYUChAQBBQ4IgXLAQoPChAQBxQRNgwSBGALEgYBAAAAAAAAABYMEgobChImBGcLEgwGBWkKGwwGCwYMDQoNChAQBxQRNAwMBHYLDAYBAAAAAAAAABYMDAoMCgA3AxQRNQwTCgwKADcEFBE2DBkEhwELGQYBAAAAAAAAABYMGQsPCgwXDA8LGwoNFwwbCgA2AAoQEAYUCgw4IwwODQ4LGTgkDBoKADYAChAQBhQNGgsTOCQ4EAoANgULGjglAQ0LCw44JQEKADYBChAQBhQNFwsNOCY4EgoANwYRURQKEBAMFAkKEBAGFAoQEAQUCwwKDwoQEAcUOQE4JwsYBNABCAwHBdQBCg8GAAAAAAAAAAAhDAcLBwT3AQoWDBUKHRADChY4KAwUChQ4KSAE5gELFDgfFAwWBegBCxQBCgA2BwsQEAYUOCoKFTgrAQodDwMLFTgsAQWCAgsQAQodDwMKFjgtDBELDwsRDwQVChsGAAAAAAAAAAAhBIcCBYgCBTILHRADOCAEoAIKCgseDAguCwg4LgEMHgoKCxw4LxEACgoKHgwJLgsJODAMHAEKGwYAAAAAAAAAACEEqQILAAELCgEFqgIFGQsLCxcCCwAAAFWiAgoANwYRURQMFgsBDBk4BwwLCwQMFwoANgIMCgoKLjgbBBkLAAELCgELCwsXAgoKLjgcDBwMHgoKLjgbIAQpBSQKHgoCJQwFBSsJDAULBQSfAgoKChw4HQwdCh0QAzgeOB8UDBUKHRADOCAgBP0BBT0KHRADChU4IQwQChAQBBQMDwkMGAoQEAUUCgMlBF0IDBgKADYAChAQBhQKEBAEFDgiChYKEDgxBcABChkKDyYEZAoPDAYFZgoZDAYLBgwMCgwKEBAHFBE1DA0KDAoANwMUETUMEgoMCgA3BBQRNgwaBH8LGgYBAAAAAAAAABYMGgsPCgwXDA8LGQoMFwwZCgA2AAoQEAYUCgw4IwwODQ4LGjgkDBsKADYAChAQBhQNGwsSOCQ4EAoANgULGzglAQ0LCw44JQEKADYBChAQBhQNFwsNOCY4EgoWChAQDBQJChAQBhQKEBAEFAsMCg8KEBAHFDkBOCcLGATFAQgMBwXJAQoPBgAAAAAAAAAAIQwHCwcE7AEKFQwUCh0QAwoVOCgMEwoTOCkgBNsBCxM4HxQMFQXdAQsTAQoANgcLEBAGFDgqChQ4KwEKHQ8DCxQ4LAEF9wELEAEKHQ8DChU4LQwRCw8LEQ8EFQoZBgAAAAAAAAAAIQT8AQX9AQU3Cx0QAzggBJUCCgoLHgwILgsIOC4BDB4KCgscOC8RAAoKCh4MCS4LCTgwDBwBChkGAAAAAAAAAAAhBJ4CCwABCwoBBZ8CBR4LCwsXAgwAAABWqgIKADcGEVEUDBYLAwwKOAgMFwoANggMCQoJLjgbBBcLAAELCQELCgsXAgoJLjgyDBwMHgoJLjgbIAQnBSIKHgoBJgwEBSkJDAQLBASnAgoJChw4HQwdCh0QAzgeOB8UDBUKHRADOCAgBIQCBTsKHRADChU4IQwPCg8QBBQMDgkMGAoPEAUUCgIlBGEIDBgKDxAEFAoPEAcUETUMEQoANgEKDxAGFAsRODMKFgoPODEFxgEOCjgYDBkKGQoOJgRrCg4MBQVtCxkMBQsFDAsKCwoPEAcUETUMDAoMCgA3AxQRNQwSCgwKADcEFBE2DBoEhgELGgYBAAAAAAAAABYMGgsOCgsXDA4KADYBCg8QBhQLDDg0DA0NDQsaOCYMGwoANgEKDxAGFA0bCxI4JjgSCgA2CQsbODUBDRcLDTg1AQoANgAKDxAGFA0KCgs4JDgQCgA3BhFRFAoPEAwUCAoPEAYUCg8QBBQLCwoOCg8QBxQ5ATgnCxgEywEIDAYFzwEKDgYAAAAAAAAAACEMBgsGBPIBChUMFAodEAMKFTgoDBMKEzgpIAThAQsTOB8UDBUF4wELEwEKADYHCw8QBhQ4KgoUOCsBCh0PAwsUOCwBBf0BCw8BCh0PAwoVOC0MEAsOCxAPBBUOCjgYBgAAAAAAAAAAIQSDAgWEAgU1Cx0QAzggBJwCCgkLHgwHLgsHODYBDB4KCQscOC8RAAoJCh4MCC4LCDgwDBwBDgo4GAYAAAAAAAAAACEEpgILAAELCQEFpwIFHAsKCxcCDQEAAFdICgEKADcKFBkGAAAAAAAAAAAhBAkFEQsAAQsGAQsFAQcFJwsCBCcLAAsBBxsLBRE+CwQ4ETg3DAkMBw0DCwcKBjgZODgLCQsGOBoMBAVFCwEOAzg5JQQtBTULAAELBgELBQEHEScLAAcaCwURPgsDOA84OgwICgY4GQwDDQQLCAsGOBo4OwsDCwQCDgAAAFl1CgU4DgwNCgMEHgoCCgERNQwLCgA2AQsFCws4PAoANwsUDAoKADcLFAYBAAAAAAAAABYKADYLFQoANggMCAUyCgA2AAsFCgI4PQoANwwUDAoKADcMFAYBAAAAAAAAABYKADYMFQoANgIMCAoKCgEKAgoDCg0LBBIEDAkKCAoBDAcuCwc4MAwMIARLCggKAQoBCgY4PhIFOD8MDAsICww4HQ8DCgoLCThACgA3BhFRFAoKCwMKDQsCCgE5AjhBCgA3BwoNOEIgBGoKADYHCg0LBjhDOEQFbAsGAQsANgcLDTgqCgoLAThFCwoCDwEAAGDyAQoCBgAAAAAAAAAAJAQFBQ8LAAELCAELBgELBwEHBScKAQoANw0UGQYAAAAAAAAAACEEGAUiCwABCwgBCwYBCwcBBwQnCgIKADcKFBkGAAAAAAAAAAAhBCsFNQsAAQsIAQsGAQsHAQcFJwoECgYRPiQEOwVFCwABCwgBCwYBCwcBBxQnCgc4DgwTCgMEcQoANwEKEzhGDBIKADYBCgcKEjhHDA4KAAoCCgELBhE+Cw44NwwQDAoOCjgYDAwLEg4QOEgXDBEKADYAChMLCjgQCgA2AQsTCxA4EgWRAQoANgAKBwoCOEkMCQoACgELBhE+Cwk4OgwPDAsKAg4LOBgXDAwODzhIDBEKADYAChMLCzgQCgA2AQsTCw84EgoFBxchBKABCwABCwgBCwcBCwwLEQkGAAAAAAAAAAACCgUHGCEEtgELAAELCAELBwEKDAsCIQSvAQWxAQcIJwsMCxEJBgAAAAAAAAAAAgoFBxkhBNUBCgwGAAAAAAAAAAAhBL8BBccBCwABCwgBCwcBBwknCwALAQsCCwMLBAsHCwg4SgwNCwwLEQgLDQILBQcWIQTaAQXiAQsAAQsIAQsHAQcNJwsACwELAgoMFwsDCwQLBwsIOEoMDQsMCxEICw0CEAAAAAEECwAHGyMCEQAAAAETCwAKARAMFAoBEBQUCgEQBhQKARAEFAsBEAcUOQM4SwISAQAAY24LAjgODAwKADcHCgw4QgQJBQ0LAAEHCycKADYHCgw4KgwNCg0KAQwDLgsDOEwEGgUgCw0BCwABBwInCg0KAQwELgsEOE0UDAsKAREQDAgKCAQxCgA3CAwFBTQKADcCDAULBQsLODAMCgQ6BUALDQELAAEHAicKCARGCgA2CAwGBUkKADYCDAYLBgsNCwoLAQoMOE4MCQsIBGAOCRAEFA4JEAcUETUMBwoANgELDAsHODMFZwoANgALDA4JEAQUOCILADcGEVEUDgk4MQITAAAAZDYLAQoDOCsBCgAKAgwFLgsFOE8QAwoDOFAEDwUTCwABBwInCgAKAjgdDAYKBg8DCwM4LAwHDgcQBhQLBCEEIwUpCwABCwYBBwMnCwYQAzggBDILAAsCOC8RAAU0CwABCwcCFAEAAGVoCgA3BhFRFAwLCwE4DgwNCgA3BwoNOEIEDgUSCwABBgAAAAAAAAAAJwoANgcKDTgqDA4KDi44USAEYwUdCg4uOFI4HxQMCQoOCgkMAi4LAjhNFAwKCgkREAwGCgYENAoANggMAwU3CgA2AgwDCwMMBwoHCwoMBC4LBDgwDAwBCwcKDgsMCwkKDThODAgLBgRYDggQBBQOCBAHFBE1DAUKADYBCg0LBTgzBV8KADYACg0OCBAEFDgiCgsOCDgxBRcLDgELAAECFQEAAGakAQoANwYRURQMEAsCOA4MEwoANwcKEzhCBA4FEgsAAQYAAAAAAAAAACcGAAAAAAAAAAAMEQoANwg4GyAEHQoANwgMAwUgCgA3AgwDCwMKEThPEBUUDBIOAUEUDAsGAAAAAAAAAAAMCQoANgcKEzgqDBQKCQoLIwSfAQU1DgEKCUIUFAwPChQKDwwELgsEOEwEQgVICxQBCwABBwInChQKDwwFLgsFOE0UDA0KDxEQDAoKDQoSIgRwCw0MEgoKBF8KADcIDAYFYgoANwIMBgsGChI4MAwMBGgFbgsUAQsAAQcKJwsMDBEKCgR2CgA2CAwHBXkKADYCDAcLBwoUChELDwoTOE4MDgsKBJABDg4QBBQODhAHFBE1DAgKADYBChMLCDgzBZcBCgA2AAoTDg4QBBQ4IgoQDg44MQsJBgEAAAAAAAAAFgwJBTALFAELAAECFgEAAGdUCwE4DgwHCgA3BwsHOFMMCEAbAAAAAAAAAAAMAwoIOFQMBQoFOCkgBEwFEgoICgU4HxQ4TRQMBgoFOB8UERAEJAoANwgLBjhVDAIFKQoANwILBjhVDAILAhADCgU4HxQ4IQwEDQMKBBAMFAoEEAcUCgQQBBQKBBAUFAoEEAYUCwQQBRQSBEQbCggLBTgfFDhWDAUFDQsIAQsAAQsFAQsDAhcBAABoFAsBOA4MBgoANwAKBjhXDAMMAgsANwELBjhYDAUMBAsCCwMLBAsFAhgBAABpVgoANwg4HAEMCAoBCggjBAsLCAwBCgA3CDgyAQwHCgIKByQEFgsHDAIKADcICwE4WQwBCgA3CAsCOFkMAkAUAAAAAAAAAAAMCUAUAAAAAAAAAAAMBQoBBgAAAAAAAAAAIQQvCwABCwMBCwkLBQIKAQoCJQRTBTQKADcICgEKAxE+OFoMBA0JCgFEFA0FCwREFAoANwgLATguAQwGCgYGAAAAAAAAAAAhBFALAAELAwEFUwsGDAEFLwsJCwUCGQEAAGlWCgA3AjgcAQwICgEKCCMECwsIDAEKADcCODIBDAcKAgoHJAQWCwcMAgoANwILAThZDAEKADcCCwI4WQwCQBQAAAAAAAAAAAwJQBQAAAAAAAAAAAwFCgEGAAAAAAAAAAAhBC8LAAELAwELCQsFAgoBCgIlBFMFNAoANwIKAQoDET44WgwEDQkKAUQUDQULBEQUCgA3AgsBOC4BDAYKBgYAAAAAAAAAACEEUAsAAQsDAQVTCwYMAQUvCwkLBQIaAAAAajELAAsBOFUQAwwGBgAAAAAAAAAADAMKBjgeDAUKBTgpIAQrBQ8KBgoFOB8UOCEMBAoEEAUUCgIkBCILAwsEEAQUFgwDBSQLBAEKBgsFOB8UOCgMBQUKCwYBCwUBCwMCGwEAAGsdCwI4DgwFCgA3BwsFOFMKAThNFAwECgEHGyMEEwsANwgMAwUWCwA3AgwDCwMLBDhVEAMLATghAgYKBgsGAgUBBAIEBQQEBAEGBwYGBg0GAAQABgUGAQYOBgkGAwYEBggEAwUAADUBNQI1CDUJNQo1CzUNNQ41DzUQNRE1EjUTNQAEbWF0aLECoRzrCwYAAAAHAQACAwIPBREPByAdCD0gBl0cDHmYAQABAAIAAQAAAwACAAAAAAIAAgMDAQMCAQMCBAQDAQQECWRpdl9yb3VuZARtYXRoA211bAltdWxfcm91bmQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QMIAMqaOwAAAAAEEADKmjsAAAAAAAAAAAAAAAAAAQAAAw0LADUMAgsBNQwDCwILAxgHARo0AgEBAAAEGgsANQwDCwE1DAQIDAIKAwoEGAcBGTIAAAAAAAAAAAAAAAAAAAAAIQQSCQwCCwILAwsEGAcBGjQCAgEAAAQcCwA1DAMLATUMBAgMAgoDBwA1GAoEGTIAAAAAAAAAAAAAAAAAAAAAIQQTCQwCCwILAwcANRgLBBo0AgAHY3JpdGJpdNscoRzrCwYAAAAOAQAGAgYcAyLCAQTkATYFmgLrAQeFBJkECJ4IQAbeCHgK1gkzC4kKBAyNCtkRDeYbHA6CHBQPlhwCAA0BKwEsAAIGAQAAAAEGAAAABAEEAAEDDAIHAQQBAgQCAAAfAAEBBAAqAgMBBAAVAgQBBAAeAgUBBAAdAgUBBAAkBgUBBAAhBgUBBAAaBgMBBAAoBgMBBAATBwMBBAARBggBBAAQBgMBBAAmCQoBBAAKCQsBBAAHBgwBBAAIBgwBBAAPAQ0BBgAOAQ0BBAASBgMBBAAtDg0BBAAWDwQBBAAMEBEAAQUaDQIHBAEGFhcCBwQBCRweAgcEAQ4TDQIHBAEPEw0CBwYBFRUEAgcEARsVAwIHBAEfABMCBwQBJRwdAgcEHRIdFBwUGxQCChcUCgoUChcSCAoHChYUEgoWEhMKBgoFCh4UAQoYEhgUHhIOChoSGhQZFBkSAQcIBAELAgEJAAEGCwIBCQABAwEBAgMDAgYLAgEJAAMDBwsCAQkAAwkAAgEDAgcLAgEJAAMBCQABBwkAAQYJAAAEBwsCAQkAAwMBAwYLAgEJAAMDAQQBAgIDCAEBCwMCCQAJAQIDCwABCQABBgsDAgkACQECBgsDAgkACQEJAAEGCQEEAQMDAxADAwMDAwIGCAEBAQgBAwMLAAEJAAMDAwMHCwMCCQAJAQkACQEQAwMDAwMDAwMDAQMDBggBAwMJAAIHCwMCCQAJAQkAAQkBAQcJAQILAwIDCAELAwIDCwABCQACBggBAwICAgtDcml0Yml0VHJlZQxJbnRlcm5hbE5vZGUETGVhZgVUYWJsZQlUeENvbnRleHQDYWRkBmJvcnJvdxRib3Jyb3dfbGVhZl9ieV9pbmRleBJib3Jyb3dfbGVhZl9ieV9rZXkKYm9ycm93X211dBhib3Jyb3dfbXV0X2xlYWZfYnlfaW5kZXgEY2xvYhNjb3VudF9sZWFkaW5nX3plcm9zB2NyaXRiaXQNZGVzdHJveV9lbXB0eQRkcm9wEGZpbmRfY2xvc2VzdF9rZXkJZmluZF9sZWFmHWdldF9jbG9zZXN0X2xlYWZfaW5kZXhfYnlfa2V5C2luc2VydF9sZWFmDmludGVybmFsX25vZGVzCGlzX2VtcHR5DWlzX2xlZnRfY2hpbGQDa2V5BmxlYXZlcwpsZWZ0X2NoaWxkDmxlZnRfbW9zdF9sZWFmBmxlbmd0aARtYXNrCG1heF9sZWFmCG1pbl9sZWFmA25ldxhuZXh0X2ludGVybmFsX25vZGVfaW5kZXgJbmV4dF9sZWFmD25leHRfbGVhZl9pbmRleAZwYXJlbnQNcHJldmlvdXNfbGVhZgZyZW1vdmUUcmVtb3ZlX2xlYWZfYnlfaW5kZXgLcmlnaHRfY2hpbGQPcmlnaHRfbW9zdF9sZWFmBHJvb3QEc2l6ZQV0YWJsZQp0eF9jb250ZXh0DHVwZGF0ZV9jaGlsZAV2YWx1ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAMIBgAAAAAAAAADCAcAAAAAAAAAAwgIAAAAAAAAAAMICQAAAAAAAAADCAAAAAAAAACAAwj//////////wMI/////////38AAgMXAy4JACMDAQIEHAMZAycDIwMCAgcpAxQLAwIDCAEYCwMCAwsAAQkAHgMdAyADIgMCCgAKAAMAAA0LBwkKADgACwA4AQcJBwkGAAAAAAAAAAAGAAAAAAAAAAA5AAIBAwAADQQLADcAOAICAgMAAA0ECwA3ADgDAgMDAAANFQoAOAQgBAUFCQsAAQcEJwoANwAKADcBFDgFNwIUCwA3ARQCBAMAAA0VCgA4BCAEBQUJCwABBwQnCgA3AAoANwMUOAU3AhQLADcDFAIFAQAAGE4KAAsBOAYMAwEKAwcJIgQKBQ4LAAEHBCcHCgoDFwwFCgA3AAsDOAU3BBQMBAoEBwkiBCQFHgoACgQLBTgHDAIFJgkMAgsCBDILBAwFCgA3BQoFOAgQBhQMBAUZCgQHCSEEOwsAAQYAAAAAAAAAAAcJAgcKCgAKADcFCwQ4CBAHFDgJFwwDCwA3AAoDOAU3AhQLAwIGAwAAGE8KAAsBOAYMAwEKAwcJIgQKBQ4LAAEHBCcHCgoDFwwFCgA3AAsDOAU3BBQMBAoEBwkiBCUFHgoACgQLBTgHIAwCBScJDAILAgQzCwQMBQoANwUKBTgIEAYUDAQFGQoEBwkhBDwLAAEGAAAAAAAAAAAHCQIHCgoACgA3BQsEOAgQCBQ4ChcMAwsANwAKAzgFNwIUCwMCBwAAAAMTCwEMAgoCBwkjBA8FBwoANwULAjgIEAcUDAIFAgsAAQsCAggAAAADEwsBDAIKAgcJIwQPBQcKADcFCwI4CBAIFAwCBQILAAELAgIJAwAAGfcBCgELAgcJOQEMDwoANwYUDBAKADcGFAYBAAAAAAAAABYKADYGFQoQBwsGAQAAAAAAAAAXIwQYBRwLAAEHAScKADYAChALDzgLCgAKAQwDLgsDOAwMBwoHBwkhBEUKEAYAAAAAAAAAACEEMQU1CwABBwInBwoKEBcKADYHFQoQCgA2ARULEAsANgMVBgAAAAAAAAAAAgoANwALBzgFNwIUDAYKBgoBIgRRBVULAAEHAycxQAsGCgEdNREVMUAXFwwIBgEAAAAAAAAACwgxARcvDBEKEQcJBwkHCRIBDAwKADcIFAwNCgA3CBQGAQAAAAAAAAAWCgA2CBUKADYFCg0LDDgNCgA3BxQMEgcJDA4KEgcJIwSpAQWHAQoANwUKEjgIDAkKEQoJEAwUJASVAQsJAQWpAQsSDA4KAQoJEAwUHAYAAAAAAAAAACEEpAELCRAHFAwSBagBCwkQCBQMEgWCAQoOBwkhBLIBCg0KADYHFQXBAQoACg4KEgwFDAQuCwQLBTgHDAoKAAsOCg0LCjgOCxEKARwGAAAAAAAAAAAhDAsKAAoNBwoKEBcKCzgOCgALDQsSCwsgOA4KADcACgA3ARQ4BTcCFAoBJATjAQoQCgA2ARUKADcACgA3AxQ4BTcCFAsBIwTzAQoQCwA2AxUF9QELAAELEAIKAwAAAxsKADgEBAgLAAEJBwkCCgAKATgMDAILADcACgI4BTcCFAsBIgQYCQcJAggLAgILAwAAAxIKADgEBAcLAAEGAAAAAAAAAAACCgALATgMDAILADcACwI4BTcCFAIMAwAAG6sBCgA3AAoBOAU3AhQMDAoANwEUCgEhBBkKAAoMDAQuCwQ4DwwJAQsJCgA2ARUKADcDFAoBIQQrCgALDAwFLgsFOBAMCgELCgoANgMVCgA2AAoBOBE6AQwPDBEBCgAuOBIGAAAAAAAAAAAhBE4HCQoANgcVBwkKADYBFQcJCgA2AxUGAAAAAAAAAAAKADYIFQYAAAAAAAAAAAsANgYVBakBCg8HCSIEUwVXCwABBwYnCgA3BQoPOAgMDgoOEAYUDA0KAAoPBwoLARcMBwwGLgsGCwc4BwRxCw4QCBQMCAV1Cw4QBxQMCAsIDBAKDQcJIQSVAQoQBwkjBIcBBwkKADYFChA4Ew8GFQWQAQcJCgA2AAcKChAXOBQ2BBULEAoANgcVBaQBCgAKDQoPDAMMAi4LAgsDOAcMCwoACw0LEAsLOA4LADYFCw84FQELEQINAwAADQYLADYACwE4FDYJAg4DAAANBgsANwALATgFNwkCDwMAAAMOCgALATgGDAIEBgUKCwABBwQnCwALAjgWAhADAAAfDgsAOgABAQEBDAIMAQELATgXCwI4GAIRAwAAHxcOADcAOAIGAAAAAAAAAAAhBAcFCQYAAAAAAAAAACcLADoAAQEBAQwCDAEBCwI4GQsBOBoCEgAAACAuCgA3BxQMAwoDBwkhBAwLAAEHCQIKAwcJIwQoBREKADcFCwM4CAwCCgEKAhAMFBwGAAAAAAAAAAAhBCMLAhAHFAwDBScLAhAIFAwDBQwLAAEHCgsDFwITAAAADTcKAQcJIgQFBQkLAAEHBycLAwQTCgIKADYFCgE4Ew8HFQUaCgIKADYFCgE4Ew8IFQoCBwkiBDQKAgcJJAQsCwELADYABwoLAhc4FDYEFQUzCwELADYFCwI4Ew8GFQU2CwABAhQAAAANCQsANwULATgIEAcUCwIhAhUAAAAhawoAMgAAAAAAAAAAAAAAAAAAAAAhBAcxgAwBBWkxAAwCCgAyAAAAAAAAAAD//////////xwyAAAAAAAAAAAAAAAAAAAAACEEFwsAMUAvDAALAjFAFgwCCgAyAAAAAAAAAAAAAAAA/////xwyAAAAAAAAAAAAAAAAAAAAACEEJQsAMSAvDAALAjEgFgwCCgAyAAAAAAAAAAAAAAAAAAD//xwyAAAAAAAAAAAAAAAAAAAAACEEMwsAMRAvDAALAjEQFgwCCgAyAAAAAAAAAAAAAAAAAAAA/xwyAAAAAAAAAAAAAAAAAAAAACEEQQsAMQgvDAALAjEIFgwCCgAyAAAAAAAAAAAAAAAAAAAA8BwyAAAAAAAAAAAAAAAAAAAAACEETwsAMQQvDAALAjEEFgwCCgAyAAAAAAAAAAAAAAAAAAAAwBwyAAAAAAAAAAAAAAAAAAAAACEEXQsAMQIvDAALAjECFgwCCwAyAAAAAAAAAAAAAAAAAAAAgBwyAAAAAAAAAAAAAAAAAAAAACEEZwsCMQEWDAILAgwBCwECAgICAwAAAgQAAgIBAQMBAQECAgYCAAIFAQAAAQAKAQoCCgMKBAoFCgkKCgoLCg0KAAsACWN1c3RvZGlhbtsMoRzrCwYAAAAOAQAMAgwwAzykAQTgAR4F/gH2AQf0A8AECLQIQAb0CAoK/ggmC6QJBAyoCeACDYgMCA6QDAYPlgwCABcBDwEVASMBJQEmAAAEAQABAAEMAAAEDAEAAQECBAEAAQIDDAEAAQMFBwADCAQABAYMAgcBBAEFBwIAACEAAQAACgIDAQAAIgAEAQAAKgUGAQAAKwUGAQAAHAcIAQAAGAkKAQAAHQsIAQAAGQwKAQAAHwkIAQAAKAwIAQAACQINAQAADAINAQAAEw4PAQAAEQIQAQABHhoNAQABJB0KAQABKRcNAQABLAgKAQACGhkGAQADIgARAAMnGxwABA0fCAIHBAQQFRYCBwQEEiAhAgcEBBYVHgIHBAQiABgCBwQXFBETGhQGExMTDRMPExATBxMIEwUTGRQSExYUGBQBBwgIAQgBAgYLAgEJAAgFAgMDAQsCAQkABAcLAgEJAAMGCAEHCAgBCwQBCQADBwsCAQkACAULAwEJAAADBwsCAQkABggBAwELAwEJAAMHCwIBCQAGCAELAwEJAAMHCwIBCQAIBQMBAwIHCwIBCQAIBQEHCwABCQABBgsAAQkAAQgGAwYLAAEJAAMDAQkAAggFCwABCQACBgsHAgkACQEJAAEGCQEBBgsDAQkAAQsHAgkACQECCwMBCQAHCAgCBwsDAQkACwMBCQABBggGAQgFAgcLAwEJAAMBAQMHCwcCCQAJAQkACQECBwsHAgkACQEJAAEHCQEHQWNjb3VudApBY2NvdW50Q2FwB0JhbGFuY2UEQ29pbglDdXN0b2RpYW4CSUQFVGFibGUJVHhDb250ZXh0A1VJRBlhY2NvdW50X2F2YWlsYWJsZV9iYWxhbmNlD2FjY291bnRfYmFsYW5jZRBhY2NvdW50X2JhbGFuY2VzFmFjY291bnRfbG9ja2VkX2JhbGFuY2UDYWRkEWF2YWlsYWJsZV9iYWxhbmNlB2JhbGFuY2UGYm9ycm93FmJvcnJvd19hY2NvdW50X2JhbGFuY2UKYm9ycm93X211dBpib3Jyb3dfbXV0X2FjY291bnRfYmFsYW5jZQRjbG9iBGNvaW4IY29udGFpbnMJY3VzdG9kaWFuH2RlY3JlYXNlX3VzZXJfYXZhaWxhYmxlX2JhbGFuY2UcZGVjcmVhc2VfdXNlcl9sb2NrZWRfYmFsYW5jZQxmcm9tX2JhbGFuY2UCaWQfaW5jcmVhc2VfdXNlcl9hdmFpbGFibGVfYmFsYW5jZRxpbmNyZWFzZV91c2VyX2xvY2tlZF9iYWxhbmNlBGpvaW4MbG9ja19iYWxhbmNlDmxvY2tlZF9iYWxhbmNlEG1pbnRfYWNjb3VudF9jYXADbmV3Bm9iamVjdAVzcGxpdAV0YWJsZQp0eF9jb250ZXh0DHVpZF90b19pbm5lcg51bmxvY2tfYmFsYW5jZQV2YWx1ZRN3aXRoZHJhd19iYXNlX2Fzc2V0FHdpdGhkcmF3X3F1b3RlX2Fzc2V0BHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgBAAAAAAAAAAACAg4LAwEJACALAwEJAAECARsIBgICAhsIBgsLBwIIBQsAAQkAAhMAEwABAAAIBAsAERQSAQIBAwAAEhALADcACwE4AAwCCgI3ATgBDAMLAjcCOAEMBAsDCwQCAgMAAAgGCgARFAsAOAI5AAIDAwAACAcLAAsCCwE4AwsDOAQCBAMAAAgHCwALAgsBOAMLAzgEAgUDAAAICAsACwE4BTYBCwI4BgECBgMAAAgJCwALARADERU4BTYBCwI4BwIHAwAACAoLAAsBEAMRFTgFNgILAjgGAQIIAwAACAcLAAsBOAU2AgsCOAcCCQMAAAoKCgAKAQsCOAMMAwsACwELAzgIAgoDAAAKCgoACgELAjgJDAMLAAsBCwM4CgILAwAACAcLADcACwE4ADcBOAECDAMAAAgHCwA3AAsBOAA3AjgBAg0AAAAIEgoANwAKATgLIAQNCgA2AAoBOAw4DDkBOA0LADYACwE4DgIOAAAACA8KADcACgE4CwQGBQoLAAEHACcLADcACwE4AAICAQAAAAEBAAATARMCEwAUAA0JY3VzdG9kaWFuB0FjY291bnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QljdXN0b2RpYW4KQWNjb3VudENhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pCWN1c3RvZGlhbglDdXN0b2RpYW4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6Qdjcml0Yml0BExlYWYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6Qdjcml0Yml0DEludGVybmFsTm9kZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pB2NyaXRiaXQLQ3JpdGJpdFRyZWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QRjbG9iC1Bvb2xDcmVhdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukEY2xvYgtPcmRlclBsYWNlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pBGNsb2INT3JkZXJDYW5jZWxlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7pBGNsb2ILT3JkZXJGaWxsZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QRjbG9iBU9yZGVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ukEY2xvYglUaWNrTGV2ZWwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QRjbG9iBFBvb2wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADe6QIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQAAAAAAAAADIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9jYXAfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAABAQAAAAAAAABAAHqbsn8OpKKfQ7vwEvZfunbBp0u71UctBl6cV5veQ1PuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjADuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjCA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAEBAQAAAAAAAAAoBwnRr+4OFRx+9xpBP6AJklpKh6LPY0JTdxSt8dX+e9UAAENP15RqAAB7gyC3+hQw3PBZTqueIMXSiSbGrSFnT7J7B9e7Z4tH0SA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMc3Rha2luZ19wb29sFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQAAAQAAAAAAAAA4CYMkAqiMkEcvpmNpYmiU/Vy85L6Wh5xsOEIo9GSykq8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEPbgCrvFItofhUCCKD+1RwzNdqLhu4M4f9rV4nsUQ2AgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKA/UP31tlxtnGYat9GhBzyjbn1CvsLg7ushPyh4H2ov+AABDT9eUagAASbqjLqQLRaVJBEqkO9WZIS+2HRyXkMY0r1OcHCjH2dsgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKCEZKPioHQ6EK4IiUcJ2Izh65HrwDnMxA28tLtjn6Q3OAABDT9eUagAAe4Mgt/oUMNzwWU6rniDF0okmxq0hZ0+yewfXu2eLR9EgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKDBKGP+E0kg67W3UBbJ3Xbv4tLxmLUk+U9UnJuN6xnXiAABDT9eUagAASbqjLqQLRaVJBEqkO9WZIS+2HRyXkMY0r1OcHCjH2dsgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKDfCnsKTwyVNanGnsZeJxyKcxqNXAtlEddwihLxQ7k57AABDT9eUagAADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCAgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX2NhcB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwAAEBAAAAAAAAAEBCsDx7L8K+gWjtx/EP+rtuYWR86pOMKzz58OWFnTKsJ2swbQww+L6NZtj1wibPCFcCRPBJ/Kd+mybJY5X5JRsSAGswbQww+L6NZtj1wibPCFcCRPBJ/Kd+mybJY5X5JRsSIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAAChKNeYcaXF/YHYE1Sj7GRXDsEV6B3b2bEkuwUaRhuDWfQAAQ0/XlGoAALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYvIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAAChM4jLNAglbpQnWaZZQ8RHQOjPXmJ3l2xJoKm+6KBUrrgAAQ0/XlGoAAEm6oy6kC0WlSQRKpDvVmSEvth0cl5DGNK9TnBwox9nbIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAgABAAAAAAAAAFBRKdl9Yt19UpGKCsmRSlDWhiQ3V8hUvA+NClz44p+gkeI0jXDjbx6aK976Je9kNGE85R4sU4I2M+QXJn6zBfXvAAAAAAAAAAAAAILf5A1HAABrMG0MMPi+jWbY9cImzwhXAkTwSfynfpsmyWOV+SUbEiA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZvYmplY3QCSUQABAABAAAAAAAAAGBgfIsUNYTWCBwV6nvXQAxIphrbHJ7mDz0qIu/h5JMlELRlf1hkJmZjOWn2aj29My5Fn0dzIw0TLJ3cFPEot9D47jVL4xqhzJpt7/k0yHfLDJvMAQYVZAeoSdHGasv23IwBH5X7PezikvbL9aJSs1MhPPUujX8SkkZ3tOp4HN/HnjogOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKGG1E0/OoMAWydFtrH2zwQEnlSCY03U50NzifCTRD7hvAABDT9eUagAAtqGXTARPET/4NEhSJPrRIEHWQXOsaeobUpmOqmJRVi8gOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAICBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXITU3VpU3lzdGVtU3RhdGVJbm5lcgAAAQAAAAAAAACfGmryorfKYL92F0rf0+nElX+Ok3dZYDGC+bRsf2xfGcbSAQAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAQAAAAAAAAAAAAh+kzccAQQdlqGWc4hYr9v2AUTi0cWqjRDVpFw3WhCtgvkiAFE0GmCNz/bRVQQKZW9IGbExEbUsV0aoa6cvOV+6/i7DhH0egUDmJKdR/fa18gULxyBc+dMABMkLDHQK/9Mmzmc8wrI6LSTVPir+sobfxmj9QGAInW0rF7eZ3Tb5DTMuVKejONQgXw9Cyz+yDdV3cDOIMglk+TUdmXMTwEoDIkcGDSFLLnEgNzcStuIbnPffsBHiunWHMc4LcUlzICVo1U95+8yxd0kwiyzWtDylvqPLC+t6rUZeJFE6XLu39wLim2VBbz6NAb3a9tiL09BgKVbugWjBAwqkC3ZhbGlkYXRvci0xAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zMzM1NS9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC80NjMzNRgvaXA0LzEyNy4wLjAuMS91ZHAvNDIwMzkYL2lwNC8xMjcuMC4wLjEvdWRwLzM5ODU5AAAAAAAAAAAHILRUHKflqCQ6XlUQIcvq3QMXSSZwaCnEEUgkkENUsQAAAAAAAAAAxAkAAAAAAACTUVVPz8b4Xk1FkdnT000IXQ4QZNveyI+mLkBEzvWKyugDAAAAAAAAKy99JiJBKTD5NRW3IWxgJIMbYO1PHb7BK6zx6IKb7MgBAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAk8OcOHHTZYqWVqUUx83pyU4uLCAM8PPRW5Mg+VhHpX4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyX/uAqGGEFaDV6mBiFQEslfqFrHjwiD4Ip+CIUUS9kAAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAAEcs98D4eYltE4bUFz9hTqzOoO+B21sTPFiPFEzAULNyAAAAAAAAAADuNUvjGqHMmm3v+TTId8sMm8wBBhVkB6hJ0cZqy/bcjGCZ8l72H4AyuRRjZGCYLFzG8TTvHdrnZlfyy/7B6/yNCXN0CA32/PDcuLxLDY4K9dgOu/8rTFmfVPQtYxLfwxQnYHjBzDR+u77FGYviWFE/OGuTDQLCdJqAPiMwlV69GhAgzmDjB34Co2g0Nq9FDzpFEbTECxWJVmN8r5zPETkefhAgEWzsBHlYiAE3N5D0DGMCQVlkWIKcTt9IlzeiMQ0CFtwwi4uTNREZbHVnSkLgGmQBE40j2XtrTtF/mCMsCsMrnHONz/ga9tRpQKesAW2h857NC3ZhbGlkYXRvci0wAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zNjQ1OS9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC80NDA2MRgvaXA0LzEyNy4wLjAuMS91ZHAvMzY3NDUYL2lwNC8xMjcuMC4wLjEvdWRwLzM5NDEzAAAAAAAAAAAqj9QggOfSzl4V+GoGupp0zLLjFK7Ai/kU14Z0pcplwgAAAAAAAAAAxAkAAAAAAAAAepuyfw6kop9Du/AS9l+6dsGnS7vVRy0GXpxXm95DU+gDAAAAAAAAtGV/WGQmZmM5afZqPb0zLkWfR3MjDRMsndwU8Si30PgBAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAdk7bK8RROD8dpsPXdTNoXuGWH148/rlAHPlcYlgMuhsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOALCrjh1OlDO9wp3K37FsmQUyK0Z+1veXMy6WoD6PPpAAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAAMCoc8pdZWPKGUV6q+J5JXMc4SlHoBErQiqd4mV0fA7zAAAAAAAAAACRzKvCogqNa1yKYBCVcquLQ2r6tbMDzoDk8W3A3kTxCWCt3u+U2JjIjkDb3v+RxfEF+c8sdH+28rw37APWyR7bLhpXjPVEvosJMeJfJD1ZsMMNmKFs47odbPHX9QQmmS6wrbMTSwVb6BQNLbXyX7ANg/jkIivwH9ask6H/TXnaWPIgbZCVEwsVNsDJIY6p/rDzZoWm+gs7HmfSVsxPs0CkjWkg4aJsYZ6zZso+y9AJsSdyVwZpvS5xBIkFkHq/P1vVicAwg54KGo44DGyw4IzRjcWLzbg6Jk6yWiOvJMf7BMOaTNaad3ggvrve/e4nm6wmN8RBC3ZhbGlkYXRvci0yAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zNDYzMy9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC8zMjk2NRgvaXA0LzEyNy4wLjAuMS91ZHAvMzU0NTcYL2lwNC8xMjcuMC4wLjEvdWRwLzM4Nzc3AAAAAAAAAABTNhzYGW9m5KkSFn9ArSMiPdKVXpJY3m2tPt4e9IrJagAAAAAAAAAAxAkAAAAAAAB4lQ80jeOmoKV/UC9hBPicN/10aUq5MV0cEovDw1a5ZOgDAAAAAAAA6acBh9L1XSJ3yoBV6dqFMrxVeE0xtplrp4+c1CltCD4BAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAsKJKXbPSW1XP7jTBDgMK2GrtaGaWY4MGkj4hEakxfIQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGgWz9PGeUN9QEyThBHsL0qqjU3+ySOilTRettQOhqr+AAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAANQQ3CSl/J897uufZyU7yE/TheAJXn18ZUcAhNz0IoB9AAAAAAAAAABrMG0MMPi+jWbY9cImzwhXAkTwSfynfpsmyWOV+SUbEmCz/V77XIckA6StE/EZlRNgbSM1SoRSSa6hV1ZMI/88FcbJ5lK3LXQOjKy5PLzAaGsOwMwMHHYL+0K0NlGfxagFS3ZTOpep8jmH0JfvlrHyUmuyBz+hCncZlBdyNH7ydPQgspFb94eEWlXCThj9wWKldesC0juuP55WbXxR68/rSkIg8kw7zFaMQz00lCDtKETmq8+h3WPHxOET+m/+d8OLN5cwjH1jRasTAwXh522c5CGYCtEP3OL4+3AftEv/V5VTo84aM98Vcq7RvxQRQNNvdRjFC3ZhbGlkYXRvci0zAAAAHS9pcDQvMTI3LjAuMC4xL3RjcC8zMzk1My9odHRwGC9pcDQvMTI3LjAuMC4xL3VkcC8zOTg4ORgvaXA0LzEyNy4wLjAuMS91ZHAvMzgxNzUYL2lwNC8xMjcuMC4wLjEvdWRwLzM0NjU1AAAAAAAAAAB5Bga3JMoC4IzRoFv5/VtYTjXap+MAb9AY/b0XUvqcEgAAAAAAAAAAxAkAAAAAAABCsDx7L8K+gWjtx/EP+rtuYWR86pOMKzz58OWFnTKsJ+gDAAAAAAAA4jSNcONvHpor3vol72Q0YTzlHixTgjYz5BcmfrMF9e8BAAAAAAAAAAAAAACC3+QNRwAAAAAAAAAAAAAAgt/kDUcAEPbgCrvFItofhUCCKD+1RwzNdqLhu4M4f9rV4nsUQ2ABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA960Qi0S0U6BDq5/IpdoN9qCAL0Mtadv9qsbqs0kX43AAAAAAAAAADIAAAAAAAAAAAAgt/kDUcA6AMAAAAAAADIAAAAAAAAALXy8lsznanogWAJQdi8BJRveAbXZAU0khL0/RuSvMUlAAAAAAAAAADyDLlENgEFhcdiENKB4e7ewpnQ11c5Rq+IXbCiPkqX5wAAAAAAAAAAAB+V+z3s4pL2y/WiUrNTITz1Lo1/EpJGd7TqeBzfx546BAAAAAAAAAD05hHSH05rAHQinJqI2qlgmwDYW0Ar1ZUlKvAb1YO3/AAAAAAAAAAAme3BiKhIlx5YejQ6LP0fUAchBVxU5UQnLbIE5YzOhjoAAAAAAAAAAAD8MKYtNUf67vuKdE6P5oQ1FIAoRKku2yiTHCg7VYAmMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcJgUAAAAAAAAAAAAAAACWAAAAAAAAAAAAQ0/XlGoAAACC3+QNRwAAgKGna0o1AAcAAAAAAAAAHYs50dCPQ6ybhPyI0uSJq3qb5mDjI+lgzdtX3nxAfZ4AAAAAAAAAAOgDAAAAAAAAAAAAVU5qYkJ/AAAAAAAAAAAAgMakfo0DAB4AAAAAAAAAECckK9UFd0RjYpGX8B3DEoyR+9yoxKKlGpdtNOBIobrHiQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyjYfxIcBAAAV2oCN7dMGWG9VQgN8pL4hchVVXQwtTLf/u3XRt82O5gAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdAJJRAAEAAEAAAAAAAAAYG9K5N0GAbBI9KRfwZM4xDkmJZgZRdpwBFqw+I5iZSfk6acBh9L1XSJ3yoBV6dqFMrxVeE0xtplrp4+c1CltCD6RzKvCogqNa1yKYBCVcquLQ2r6tbMDzoDk8W3A3kTxCQEflfs97OKS9sv1olKzUyE89S6NfxKSRne06ngc38eeOiA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAEBAQAAAAAAAAAocrHwMFQ2RyIvH5dN0jctJwrdKLCKrxwwE4+I55HSuHcAAENP15RqAADthnMV4/fIOugubVhYtqbMV8KR/YT3UJZG68gWIWnPliA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3JfY2FwH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAAAQEAAAAAAAAAQHiVDzSN46agpX9QL2EE+Jw3/XRpSrkxXRwSi8PDVrlkkcyrwqIKjWtcimAQlXKri0Nq+rWzA86A5PFtwN5E8QkAkcyrwqIKjWtcimAQlXKri0Nq+rWzA86A5PFtwN5E8QkgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKH/c+eGxtFPbKUcOgriLDorVsn68q/MlV4ZztI48RHUyAABDT9eUagAADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCAgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAICBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbBVQb29sVG9rZW5FeGNoYW5nZVJhdGUAAAEAAAAAAAAAOIPPqx/ASzp7pQUJomHnoaaptjY6UfDVGIjuNg5HiV5zAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXZO2yvEUTg/HabD13UzaF7hlh9ePP65QBz5XGJYDLobIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAgABAAAAAAAAAFCD1k5PxPNdgUPU8A5P0F0T6TLQG53sFFWq/UuWbxuQA+mnAYfS9V0id8qAVenahTK8VXhNMbaZa6ePnNQpbQg+AAAAAAAAAAAAAILf5A1HAACRzKvCogqNa1yKYBCVcquLQ2r6tbMDzoDk8W3A3kTxCSA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAIAAQAAAAAAAABQjrJWUBUCi6DrGMVCiRBDeF67hge4JeBmdiz2cb6EV+y0ZX9YZCZmYzlp9mo9vTMuRZ9HcyMNEyyd3BTxKLfQ+AAAAAAAAAAAAACC3+QNRwAA7jVL4xqhzJpt7/k0yHfLDJvMAQYVZAeoSdHGasv23IwgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX2NhcB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwAAEBAAAAAAAAAECTUVVPz8b4Xk1FkdnT000IXQ4QZNveyI+mLkBEzvWKyh2WoZZziFiv2/YBROLRxaqNENWkXDdaEK2C+SIAUTQaAB2WoZZziFiv2/YBROLRxaqNENWkXDdaEK2C+SIAUTQaIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACiUHTR/XH5fbwyHvE1TeYoyKoXPuds/c+6AmN2EQAvwSQAAQ0/XlGoAALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYvIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACif+8ou5m6v5tWQLynLCoTbMT3JtUpEGKNoezkhptm7AgAAQ0/XlGoAAA0PBMs887515Y/9UZvSiCITFTbuMmwAfBPaR6cAnhQgIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACijAXq/p9dM2BQpEwtYWn+/GEXo4VuA1dicvmWo6FO/RQAAQ0/XlGoAAEm6oy6kC0WlSQRKpDvVmSEvth0cl5DGNK9TnBwox9nbIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBGNvaW4MQ29pbk1ldGFkYXRhAQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNzdWkDU1VJAAEBAAAAAAAAACulo9wBjqkC8AGuUEQlGdMOdmYxqXFPMJtJfaj6xSSanQkDU3VpA1NVSQAAAyA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAEBAQAAAAAAAAAorVKLQpjShTyMFJa6S1Z2NRfOixJQLdmPsuIKA9yHDJsAAENP15RqAAB7gyC3+hQw3PBZTqueIMXSiSbGrSFnT7J7B9e7Z4tH0SA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAEBAQAAAAAAAAAotAG9KMfDh5nTAb7yCkmY70wH7b0VZdSH/6sTv7qGlGMAAENP15RqAABJuqMupAtFpUkESqQ71ZkhL7YdHJeQxjSvU5wcKMfZ2yA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZvYmplY3QCSUQABAABAAAAAAAAAGC1MJTIzFY4NvYcAOq40vVWuAJG9eQp/7hprGpOG1wz1+I0jXDjbx6aK976Je9kNGE85R4sU4I2M+QXJn6zBfXvazBtDDD4vo1m2PXCJs8IVwJE8En8p36bJsljlfklGxIBH5X7PezikvbL9aJSs1MhPPUujX8SkkZ3tOp4HN/HnjogOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKMAcdWgA5ISlSU5WNhKQU2PYbLqwpkPJ9vbm32GoCPOSAABDT9eUagAADQ8EyzzzvnXlj/1Rm9KIIhMVNu4ybAB8E9pHpwCeFCAgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGb2JqZWN0AklEAAQAAQAAAAAAAABgx/bBVyy7AWKMeFuv5r3y8Y6C+mUC1uqBMPMVQqxQXe0rL30mIkEpMPk1FbchbGAkgxtg7U8dvsErrPHogpvsyB2WoZZziFiv2/YBROLRxaqNENWkXDdaEK2C+SIAUTQaAR+V+z3s4pL2y/WiUrNTITz1Lo1/EpJGd7TqeBzfx546IDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACjNTjbpEa5n6Z6lsDppQZByGyh6FJsoBAfGQESiqtLaugAAQ0/XlGoAAO2GcxXj98g66C5tWFi2psxXwpH9hPdQlkbryBYhac+WIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACjSkCP8hjC+flK3MDTgw/8583YlaxHBSMD5dYyJhEQxiwAAQ0/XlGoAAO2GcxXj98g66C5tWFi2psxXwpH9hPdQlkbryBYhac+WIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACjVPbaUooNGZN0s/0P/AHo0OTiax02I9dl1oSwx/CDIyQAAQ0/XlGoAALahl0wETxE/+DRIUiT60SBB1kFzrGnqG1KZjqpiUVYvIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wVUG9vbFRva2VuRXhjaGFuZ2VSYXRlAAABAAAAAAAAADjWGyj7IpNTLEYSK13Xfkml+I1vcz5xoMsRrGb+jlm/8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGwokpds9JbVc/uNMEOAwrYau1oZpZjgwaSPiERqTF8hCA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAEBAQAAAAAAAAAo2xoN5HUtUP2UcTpF7ReW+p2ZDE5RHLUhXoJ3TJbmnK0AAENP15RqAAANDwTLPPO+deWP/VGb0ogiExU27jJsAHwT2kenAJ4UICA7Bjx9XE2/yKOcFS+EaDafQVhA2bQsygYV24djM/2TyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMc3Rha2luZ19wb29sFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQAAAQAAAAAAAAA42zYCSgCTK1+lM8dUMETPEjhVdAMjRG04cBtiwqMow3kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABk8OcOHHTZYqWVqUUx83pyU4uLCAM8PPRW5Mg+VhHpX4gOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKN+Z5K7+QFhNp0EMDPe0fkc5ciqr9vp3MANEd6hvuWJuAABDT9eUagAAe4Mgt/oUMNzwWU6rniDF0okmxq0hZ0+yewfXu2eLR9EgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKOD93T7kZHagd2uRlkNQ2O4HJ81FE3BNnUZz8/xN+FA8AABDT9eUagAAtqGXTARPET/4NEhSJPrRIEHWQXOsaeobUpmOqmJRVi8gOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKOzttkGbkRDdqk0UX0PTgzZL1rWejAZw+GBSDSDqBpgvAABDT9eUagAA7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5YgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAABAQEAAAAAAAAAKO6xodBEIKA4CT/RgTexRuZLKamQ425++rBXsm6Bn8lSAABDT9eUagAA7YZzFeP3yDroLm1YWLamzFfCkf2E91CWRuvIFiFpz5YgOwY8fVxNv8ijnBUvhGg2n0FYQNm0LMoGFduHYzP9k8gAAAAAAAAAAAACAAEAAAAAAAAAUPdmHL9ncVy6VvG8NKg7pM/GGv4DwqS/js+lKWXXCyUZKy99JiJBKTD5NRW3IWxgJIMbYO1PHb7BK6zx6IKb7MgAAAAAAAAAAAAAgt/kDUcAAB2WoZZziFiv2/YBROLRxaqNENWkXDdaEK2C+SIAUTQaIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAAAAQEBAAAAAAAAACj53Ug1HQlNHdXS1lnq6BcObvZ2YB+/ZUyZK2fLrR8eCAAAQ0/XlGoAAHuDILf6FDDc8FlOq54gxdKJJsatIWdPsnsH17tni0fRIDsGPH1cTb/Io5wVL4RoNp9BWEDZtCzKBhXbh2Mz/ZPIAAAAAAAAAAA= diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/sui.keystore b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/sui.keystore new file mode 100644 index 0000000000..47355b9391 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/sui.keystore @@ -0,0 +1,7 @@ +[ + "AB522qKKEsXMTFRD2SG3Het/02S/ZBOugmcH3R1CDG6l", + "AOmPq9B16F3W3ijO/4s9hI6v8LdiYCawKAW31PKpg4Qp", + "AOLhc0ryVWnD5LmqH3kCHruBpVV+68EWjEGu2eC9gndK", + "AKCo1FyhQ0zUpnoZLmGJJ+8LttTrt56W87Ho4vBF+R+8", + "AGA20wtGcwbcNAG4nwapbQ5wIuXwkYQEWFUoSVAxctHb" +] \ No newline at end of file diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/validator-config-0.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/validator-config-0.yaml new file mode 100644 index 0000000000..27d370a59d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/validator-config-0.yaml @@ -0,0 +1,81 @@ +--- +protocol-key-pair: + value: VTDx4HjVmRBqdqBWg2zN+zcFE20io3CrBchGy/iV1lo= +worker-key-pair: + value: ABlC9PMmIQHjxila3AEOXDxwCSuodcvJh2Q5O5HIB00K +account-key-pair: + value: AIV4Ng6OYQf6irjVCZly5X7dSpdFpwoWtdAx9u4PANRl +network-key-pair: + value: AOqJl2rHMnroe26vjkkIuWGBD/y6HzQG6MK5bC9njF0s +db-path: sui_config/authorities_db/99f25ef61f80 +network-address: /ip4/127.0.0.1/tcp/36459/http +json-rpc-address: "127.0.0.1:38133" +metrics-address: "127.0.0.1:44135" +admin-interface-port: 33917 +consensus-config: + address: /ip4/127.0.0.1/tcp/41459/http + db-path: sui_config/consensus_db/99f25ef61f80 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/44689/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/33219/http + network_admin_server: + primary_network_admin_server_port: 33945 + worker_network_admin_server_base_port: 38081 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:44061" + external-address: /ip4/127.0.0.1/udp/44061 +genesis: + genesis-file-location: sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/validator-config-1.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/validator-config-1.yaml new file mode 100644 index 0000000000..31920d77c1 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/validator-config-1.yaml @@ -0,0 +1,81 @@ +--- +protocol-key-pair: + value: avYcyVgYMXTyaUYh9IRwLK0gSzl7YF6ZQDAbrS1Bhvo= +worker-key-pair: + value: AGsxCVxeIZ6fscvGECzV93Hi4JkqM4zMYEA8wBGfXQrz +account-key-pair: + value: AF9cOMxTRAUTOws2M8W5slHf41HITA+M3nqXHT6nlH6S +network-key-pair: + value: ALH/8qz2YlwAuxY/hOvuXiglYq0e4LLU1/lyf5uKgPY8 +db-path: sui_config/authorities_db/8dcff6d15504 +network-address: /ip4/127.0.0.1/tcp/33355/http +json-rpc-address: "127.0.0.1:39573" +metrics-address: "127.0.0.1:45851" +admin-interface-port: 35739 +consensus-config: + address: /ip4/127.0.0.1/tcp/42959/http + db-path: sui_config/consensus_db/8dcff6d15504 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/37001/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/39831/http + network_admin_server: + primary_network_admin_server_port: 39853 + worker_network_admin_server_base_port: 36429 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:46335" + external-address: /ip4/127.0.0.1/udp/46335 +genesis: + genesis-file-location: sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/validator-config-2.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/validator-config-2.yaml new file mode 100644 index 0000000000..caa5501a66 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/validator-config-2.yaml @@ -0,0 +1,81 @@ +--- +protocol-key-pair: + value: OXnx3yM1C/ppgnDMx/o1d49fJs7E05kq11mXNae/O+I= +worker-key-pair: + value: AHXs8DP7EccyxtxAGq/m33LgvOApXs4JStH3PLAe9vGw +account-key-pair: + value: AC8vF9E3QYf0aTyBZWlSzJJXETvV5vYkOtEJl+DWQMlk +network-key-pair: + value: AOapcKU6mW5SopFM6eBSiXgbuPJTz11CiEqM+SJGIEOF +db-path: sui_config/authorities_db/addeef94d898 +network-address: /ip4/127.0.0.1/tcp/34633/http +json-rpc-address: "127.0.0.1:38025" +metrics-address: "127.0.0.1:43451" +admin-interface-port: 36793 +consensus-config: + address: /ip4/127.0.0.1/tcp/40307/http + db-path: sui_config/consensus_db/addeef94d898 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/37445/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/43943/http + network_admin_server: + primary_network_admin_server_port: 39611 + worker_network_admin_server_base_port: 38377 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:32965" + external-address: /ip4/127.0.0.1/udp/32965 +genesis: + genesis-file-location: sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/validator-config-3.yaml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/validator-config-3.yaml new file mode 100644 index 0000000000..0d44fa2483 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/sui_config/validator-config-3.yaml @@ -0,0 +1,81 @@ +--- +protocol-key-pair: + value: CyNkjqNVr3HrHTH7f/NLs7u5lUHJzuPAw0PqMTD2y2s= +worker-key-pair: + value: AHd6qvbBv7bTCGGoD1TUR5dOGnwOnYvhHV9ryCUp7rmZ +account-key-pair: + value: ALSCvWwsVryGIwq+n4f9bIPCRqsooGodE/vDaVCSLfjE +network-key-pair: + value: APFCK1pRVxn9PDt+KzWx52+EY5nzaZZU2GF9RZoQY58Y +db-path: sui_config/authorities_db/b3fd5efb5c87 +network-address: /ip4/127.0.0.1/tcp/33953/http +json-rpc-address: "127.0.0.1:35625" +metrics-address: "127.0.0.1:37813" +admin-interface-port: 46405 +consensus-config: + address: /ip4/127.0.0.1/tcp/43213/http + db-path: sui_config/consensus_db/b3fd5efb5c87 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/46745/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/38817/http + network_admin_server: + primary_network_admin_server_port: 34929 + worker_network_admin_server_base_port: 37447 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ +enable-event-processing: false +enable-index-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:39889" + external-address: /ip4/127.0.0.1/udp/39889 +genesis: + genesis-file-location: sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 2 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 30 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 +expensive-safety-check-config: + enable-epoch-sui-conservation-check: false + enable-deep-per-tx-sui-conservation-check: false + force-disable-epoch-sui-conservation-check: false + enable-state-consistency-check: false + force-disable-state-consistency-check: false + enable-move-vm-paranoid-checks: false diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/tsconfig.json b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/tsconfig.json new file mode 100644 index 0000000000..d6a4db0856 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/testing/tsconfig.json @@ -0,0 +1,12 @@ +{ + "compilerOptions": { + "types": ["mocha", "chai"], + "typeRoots": ["./node_modules/@types"], + "lib": ["es2020"], + "module": "commonjs", + "target": "es2020", + "strict": true, + "resolveJsonModule": true, + "esModuleInterop": true + } + } diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/.gitignore b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/.gitignore new file mode 100644 index 0000000000..378eac25d3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/.gitignore @@ -0,0 +1 @@ +build diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Makefile b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Makefile new file mode 100644 index 0000000000..b1c345e0f3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Makefile @@ -0,0 +1,18 @@ +-include ../../Makefile.help + +VERSION = $(shell grep -Po "version = \"\K[^\"]*" Move.toml | sed "s/\./_/g") + +.PHONY: clean +clean: + rm -rf build + +.PHONY: check +## Build contract +check: + sui move build -d + +.PHONY: test +## Run tests +test: check + grep "public(friend) fun current_version(): V__${VERSION} {" sources/version_control.move + sui move test -t 1 diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.devnet.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.devnet.toml new file mode 100644 index 0000000000..c63e72576d --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.devnet.toml @@ -0,0 +1,14 @@ +[package] +name = "TokenBridge" +version = "0.2.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../wormhole" + +[addresses] +token_bridge = "_" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.lock b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.lock new file mode 100644 index 0000000000..130fedfa70 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.lock @@ -0,0 +1,39 @@ +# @generated by Move, please check-in and do not edit manually. + +[move] +version = 0 +manifest_digest = "868DAEC26B76907DDD55CB64F8F3373546E028B90763B6BD8D1544F7EB721AAD" +deps_digest = "060AD7E57DFB13104F21BE5F5C3759D03F0553FC3229247D9A7A6B45F50D03A3" + +dependencies = [ + { name = "Sui" }, +] + +dev-dependencies = [ + { name = "Wormhole" }, +] + +[[move.package]] +name = "MoveStdlib" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/move-stdlib" } + +[[move.package]] +name = "Sui" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/sui-framework" } + +dependencies = [ + { name = "MoveStdlib" }, +] + +[[move.package]] +name = "Wormhole" +source = { local = "../wormhole" } + +dependencies = [ + { name = "Sui" }, +] + +[move.toolchain-version] +compiler-version = "1.19.0" +edition = "legacy" +flavor = "sui" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.mainnet.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.mainnet.toml new file mode 100644 index 0000000000..829ab68b0e --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.mainnet.toml @@ -0,0 +1,15 @@ +[package] +name = "TokenBridge" +version = "0.2.0" +published-at = "0x26efee2b51c911237888e5dc6702868abca3c7ac12c53f76ef8eba0697695e3d" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../wormhole" + +[addresses] +token_bridge = "0x26efee2b51c911237888e5dc6702868abca3c7ac12c53f76ef8eba0697695e3d" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.testnet.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.testnet.toml new file mode 100644 index 0000000000..143976d3d4 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.testnet.toml @@ -0,0 +1,15 @@ +[package] +name = "TokenBridge" +version = "0.2.0" +published-at = "0x562760fc51d90d4ae1835bac3e91e0e6987d3497b06f066941d3e51f6e8d76d0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../wormhole" + +[addresses] +token_bridge = "0x562760fc51d90d4ae1835bac3e91e0e6987d3497b06f066941d3e51f6e8d76d0" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.toml new file mode 100644 index 0000000000..ac81fbab56 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/Move.toml @@ -0,0 +1,21 @@ +[package] +name = "TokenBridge" +version = "0.2.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[dependencies.Wormhole] +local = "../wormhole" + +[addresses] +token_bridge = "_" + +[dev-dependencies.Wormhole] +local = "../wormhole" + +[dev-addresses] +wormhole = "0x100" +token_bridge = "0x200" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/attest_token.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/attest_token.move new file mode 100644 index 0000000000..c5e67d1670 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/attest_token.move @@ -0,0 +1,385 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements the method `attest_token` which allows someone +/// to send asset metadata of a coin type native to Sui. Part of this process +/// is registering this asset in the `TokenRegistry`. +/// +/// NOTE: If an asset has not been attested for, it cannot be bridged using +/// `transfer_tokens` or `transfer_tokens_with_payload`. +/// +/// See `asset_meta` module for serialization and deserialization of Wormhole +/// message payload. +module token_bridge::attest_token { + use sui::coin::{CoinMetadata}; + use wormhole::publish_message::{MessageTicket}; + + use token_bridge::asset_meta::{Self}; + use token_bridge::create_wrapped::{Self}; + use token_bridge::state::{Self, State, LatestOnly}; + use token_bridge::token_registry::{Self}; + + /// Coin type belongs to a wrapped asset. + const E_WRAPPED_ASSET: u64 = 0; + /// Coin type belongs to an untrusted contract from `create_wrapped` which + /// has not completed registration. + const E_FROM_CREATE_WRAPPED: u64 = 1; + + /// `attest_token` takes `CoinMetadata` of a coin type and generates a + /// `MessageTicket` with encoded asset metadata for a foreign Token Bridge + /// contract to consume and create a wrapped asset reflecting this Sui + /// asset. Asset metadata is encoded using `AssetMeta`. + /// + /// See `token_registry` and `asset_meta` module for more info. + public fun attest_token( + token_bridge_state: &mut State, + coin_meta: &CoinMetadata, + nonce: u32 + ): MessageTicket { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // Encode Wormhole message payload. + let encoded_asset_meta = + serialize_asset_meta(&latest_only, token_bridge_state, coin_meta); + + // Prepare Wormhole message. + state::prepare_wormhole_message( + &latest_only, + token_bridge_state, + nonce, + encoded_asset_meta + ) + } + + fun serialize_asset_meta( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + coin_meta: &CoinMetadata, + ): vector { + let registry = state::borrow_token_registry(token_bridge_state); + + // Register if it is a new asset. + // + // NOTE: We don't want to abort if the asset is already registered + // because we may want to send asset metadata again after registration + // (the owner of a particular `CoinType` can change `CoinMetadata` any + // time after we register the asset). + if (token_registry::has(registry)) { + let asset_info = token_registry::verified_asset(registry); + // If this asset is already registered, there should already + // be canonical info associated with this coin type. + assert!( + !token_registry::is_wrapped(&asset_info), + E_WRAPPED_ASSET + ); + } else { + // Before we consider registering, we should not accidentally + // perform this registration that may be the `CoinMetadata` from + // `create_wrapped::prepare_registration`, which has empty fields. + assert!( + !create_wrapped::incomplete_metadata(coin_meta), + E_FROM_CREATE_WRAPPED + ); + + // Now register it. + token_registry::add_new_native( + state::borrow_mut_token_registry( + latest_only, + token_bridge_state + ), + coin_meta + ); + }; + + asset_meta::serialize(asset_meta::from_metadata(coin_meta)) + } + + #[test_only] + public fun serialize_asset_meta_test_only( + token_bridge_state: &mut State, + coin_metadata: &CoinMetadata, + ): vector { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + serialize_asset_meta(&latest_only, token_bridge_state, coin_metadata) + } +} + +#[test_only] +module token_bridge::attest_token_tests { + use std::ascii::{Self}; + use std::string::{Self}; + use sui::coin::{Self}; + use sui::test_scenario::{Self}; + use wormhole::publish_message::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::asset_meta::{Self}; + use token_bridge::attest_token::{Self}; + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::coin_wrapped_7::{Self, COIN_WRAPPED_7}; + use token_bridge::native_asset::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + person, + return_state, + set_up_wormhole_and_token_bridge, + take_state, + }; + use token_bridge::token_registry::{Self}; + + #[test] + fun test_attest_token() { + use token_bridge::attest_token::{attest_token}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Publish coin. + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + let coin_meta = coin_native_10::take_metadata(scenario); + + // Emit `AssetMeta` payload. + let prepared_msg = + attest_token( + &mut token_bridge_state, + &coin_meta, + 1234, // nonce + ); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + // Check that asset is registered. + { + let registry = + state::borrow_token_registry(&token_bridge_state); + let verified = + token_registry::verified_asset(registry); + assert!(!token_registry::is_wrapped(&verified), 0); + + let asset = token_registry::borrow_native(registry); + + let expected_token_address = + native_asset::canonical_address(&coin_meta); + assert!( + native_asset::token_address(asset) == expected_token_address, + 0 + ); + assert!(native_asset::decimals(asset) == 10, 0); + + let ( + token_chain, + token_address + ) = native_asset::canonical_info(asset); + assert!(token_chain == chain_id(), 0); + assert!(token_address == expected_token_address, 0); + + assert!(native_asset::custody(asset) == 0, 0); + }; + + // Clean up for next call. + publish_message::destroy(prepared_msg); + + // Update metadata. + let new_symbol = { + use std::vector::{Self}; + + let symbol = coin::get_symbol(&coin_meta); + let buf = ascii::into_bytes(symbol); + vector::reverse(&mut buf); + + ascii::string(buf) + }; + + let new_name = coin::get_name(&coin_meta); + string::append(&mut new_name, string::utf8(b"??? and profit")); + + let treasury_cap = coin_native_10::take_treasury_cap(scenario); + coin::update_symbol(&treasury_cap, &mut coin_meta, new_symbol); + coin::update_name(&treasury_cap, &mut coin_meta, new_name); + + // We should be able to call `attest_token` any time after. + let prepared_msg = + attest_token( + &mut token_bridge_state, + &coin_meta, + 1234, // nonce + ); + + // Clean up. + publish_message::destroy(prepared_msg); + return_state(token_bridge_state); + coin_native_10::return_globals(treasury_cap, coin_meta); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_serialize_asset_meta() { + use token_bridge::attest_token::{serialize_asset_meta_test_only}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Publish coin. + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Proceed to next operation. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + let coin_meta = coin_native_10::take_metadata(scenario); + + // Emit `AssetMeta` payload. + let serialized = + serialize_asset_meta_test_only(&mut token_bridge_state, &coin_meta); + let expected_serialized = + asset_meta::serialize_test_only( + asset_meta::from_metadata_test_only(&coin_meta) + ); + assert!(serialized == expected_serialized, 0); + + // Update metadata. + let new_symbol = { + use std::vector::{Self}; + + let symbol = coin::get_symbol(&coin_meta); + let buf = ascii::into_bytes(symbol); + vector::reverse(&mut buf); + + ascii::string(buf) + }; + + let new_name = coin::get_name(&coin_meta); + string::append(&mut new_name, string::utf8(b"??? and profit")); + + let treasury_cap = coin_native_10::take_treasury_cap(scenario); + coin::update_symbol(&treasury_cap, &mut coin_meta, new_symbol); + coin::update_name(&treasury_cap, &mut coin_meta, new_name); + + // Check that the new serialization reflects updated metadata. + let expected_serialized = + asset_meta::serialize_test_only( + asset_meta::from_metadata_test_only(&coin_meta) + ); + assert!(serialized != expected_serialized, 0); + let updated_serialized = + serialize_asset_meta_test_only(&mut token_bridge_state, &coin_meta); + assert!(updated_serialized == expected_serialized, 0); + + // Clean up. + return_state(token_bridge_state); + coin_native_10::return_globals(treasury_cap, coin_meta); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = attest_token::E_FROM_CREATE_WRAPPED)] + fun test_cannot_attest_token_from_create_wrapped() { + use token_bridge::attest_token::{attest_token}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Publish coin. + coin_wrapped_7::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + let coin_meta = test_scenario::take_shared(scenario); + + // You shall not pass! + let prepared_msg = + attest_token( + &mut token_bridge_state, + &coin_meta, + 1234 // nonce + ); + + // Clean up. + publish_message::destroy(prepared_msg); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_attest_token_outdated_version() { + use token_bridge::attest_token::{attest_token}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Publish coin. + coin_wrapped_7::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + let coin_meta = test_scenario::take_shared(scenario); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + let prepared_msg = + attest_token( + &mut token_bridge_state, + &coin_meta, + 1234 // nonce + ); + + // Clean up. + publish_message::destroy(prepared_msg); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/complete_transfer.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/complete_transfer.move new file mode 100644 index 0000000000..c9086e7dbc --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/complete_transfer.move @@ -0,0 +1,1228 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements two methods: `authorize_transfer` and +/// `redeem_relayer_payout`, which are to be executed in a transaction block in +/// this order. +/// +/// `authorize_transfer` allows a contract to complete a Token Bridge transfer, +/// sending assets to the encoded recipient. The coin payout incentive in +/// redeeming the transfer is packaged in a `RelayerReceipt`. +/// +/// `redeem_relayer_payout` unpacks the `RelayerReceipt` to release the coin +/// containing the relayer fee amount. +/// +/// The purpose of splitting this transfer redemption into two steps is in case +/// Token Bridge needs to be upgraded and there is a breaking change for this +/// module, an integrator would not be left broken. It is discouraged to put +/// `authorize_transfer` in an integrator's package logic. Otherwise, this +/// integrator needs to be prepared to upgrade his contract to handle the latest +/// version of `complete_transfer`. +/// +/// Instead, an integrator is encouraged to execute a transaction block, which +/// executes `authorize_transfer` using the latest Token Bridge package ID and +/// to implement `redeem_relayer_payout` in his contract to consume this receipt. +/// This is similar to how an integrator with Wormhole is not meant to use +/// `vaa::parse_and_verify` in his contract in case the `vaa` module needs to +/// be upgraded due to a breaking change. +/// +/// See `transfer` module for serialization and deserialization of Wormhole +/// message payload. +module token_bridge::complete_transfer { + use sui::balance::{Self, Balance}; + use sui::coin::{Self, Coin}; + use sui::tx_context::{Self, TxContext}; + use wormhole::external_address::{Self, ExternalAddress}; + + use token_bridge::native_asset::{Self}; + use token_bridge::normalized_amount::{Self, NormalizedAmount}; + use token_bridge::state::{Self, State, LatestOnly}; + use token_bridge::token_registry::{Self, VerifiedAsset}; + use token_bridge::transfer::{Self}; + use token_bridge::vaa::{Self, TokenBridgeMessage}; + use token_bridge::wrapped_asset::{Self}; + + // Requires `handle_complete_transfer`. + friend token_bridge::complete_transfer_with_payload; + + /// Transfer not intended to be received on Sui. + const E_TARGET_NOT_SUI: u64 = 0; + /// Input token info does not match registered info. + const E_CANONICAL_TOKEN_INFO_MISMATCH: u64 = 1; + + /// Event reflecting when a transfer via `complete_transfer` or + /// `complete_transfer_with_payload` is successfully executed. + struct TransferRedeemed has drop, copy { + emitter_chain: u16, + emitter_address: ExternalAddress, + sequence: u64 + } + + #[allow(lint(coin_field))] + /// This type is only generated from `authorize_transfer` and can only be + /// redeemed using `redeem_relayer_payout`. Integrators running relayer + /// contracts are expected to implement `redeem_relayer_payout` within their + /// contracts and call `authorize_transfer` in a transaction block preceding + /// the method that consumes this receipt. + struct RelayerReceipt { + /// Coin of relayer fee payout. + payout: Coin + } + + /// `authorize_transfer` deserializes a token transfer VAA payload. Once the + /// transfer is authorized, an event (`TransferRedeemed`) is emitted to + /// reflect which Token Bridge this transfer originated from. The + /// `RelayerReceipt` returned wraps a `Coin` object containing a payout that + /// incentivizes someone to execute a transaction on behalf of the encoded + /// recipient. + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + /// + /// It is important for integrators to refrain from calling this method + /// within their contracts. This method is meant to be called in a + /// transaction block, passing the `RelayerReceipt` to a method which calls + /// `redeem_relayer_payout` within a contract. If in a circumstance where + /// this module has a breaking change in an upgrade, `redeem_relayer_payout` + /// will not be affected by this change. + /// + /// See `redeem_relayer_payout` for more details. + public fun authorize_transfer( + token_bridge_state: &mut State, + msg: TokenBridgeMessage, + ctx: &mut TxContext + ): RelayerReceipt { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // Emitting the transfer being redeemed (and disregard return value). + emit_transfer_redeemed(&msg); + + // Deserialize transfer message and process. + handle_complete_transfer( + &latest_only, + token_bridge_state, + vaa::take_payload(msg), + ctx + ) + } + + /// After a transfer is authorized, a relayer contract may unpack the + /// `RelayerReceipt` using this method. Coin representing the relaying + /// incentive from this receipt is returned. This method is meant to be + /// simple. It allows for a coordination with calling `authorize_upgrade` + /// before a method that implements `redeem_relayer_payout` in a transaction + /// block to consume this receipt. + /// + /// NOTE: Integrators of Token Bridge collecting relayer fee payouts from + /// these token transfers should be calling only this method from their + /// contracts. This method is not guarded by version control (thus not + /// requiring a reference to the Token Bridge `State` object), so it is + /// intended to work for any package version. + public fun redeem_relayer_payout( + receipt: RelayerReceipt + ): Coin { + let RelayerReceipt { payout } = receipt; + + payout + } + + /// This is a privileged method only used by `complete_transfer` and + /// `complete_transfer_with_payload` modules. This method validates the + /// encoded token info with the passed in coin type via the `TokenRegistry`. + /// The transfer amount is denormalized and either mints balance of + /// wrapped asset or withdraws balance from native asset custody. + /// + /// Depending on whether this coin is a Token Bridge wrapped asset or a + /// natively existing asset on Sui, the coin is either minted or withdrawn + /// from Token Bridge's custody. + public(friend) fun verify_and_bridge_out( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + token_chain: u16, + token_address: ExternalAddress, + target_chain: u16, + amount: NormalizedAmount + ): ( + VerifiedAsset, + Balance + ) { + // Verify that the intended chain ID for this transfer is for Sui. + assert!( + target_chain == wormhole::state::chain_id(), + E_TARGET_NOT_SUI + ); + + let asset_info = state::verified_asset(token_bridge_state); + assert!( + ( + token_chain == token_registry::token_chain(&asset_info) && + token_address == token_registry::token_address(&asset_info) + ), + E_CANONICAL_TOKEN_INFO_MISMATCH + ); + + // De-normalize amount in preparation to take `Balance`. + let raw_amount = + normalized_amount::to_raw( + amount, + token_registry::coin_decimals(&asset_info) + ); + + // If the token is wrapped by Token Bridge, we will mint these tokens. + // Otherwise, we will withdraw from custody. + let bridged_out = { + let registry = + state::borrow_mut_token_registry( + latest_only, + token_bridge_state + ); + if (token_registry::is_wrapped(&asset_info)) { + wrapped_asset::mint( + token_registry::borrow_mut_wrapped(registry), + raw_amount + ) + } else { + native_asset::withdraw( + token_registry::borrow_mut_native(registry), + raw_amount + ) + } + }; + + (asset_info, bridged_out) + } + + /// This method emits source information of the token transfer. Off-chain + /// processes may want to observe when transfers have been redeemed. + public(friend) fun emit_transfer_redeemed(msg: &TokenBridgeMessage): u16 { + let emitter_chain = vaa::emitter_chain(msg); + + // Emit Sui event with `TransferRedeemed`. + sui::event::emit( + TransferRedeemed { + emitter_chain, + emitter_address: vaa::emitter_address(msg), + sequence: vaa::sequence(msg) + } + ); + + emitter_chain + } + + fun handle_complete_transfer( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + transfer_vaa_payload: vector, + ctx: &mut TxContext + ): RelayerReceipt { + let ( + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee + ) = transfer::unpack(transfer::deserialize(transfer_vaa_payload)); + + let ( + asset_info, + bridged_out + ) = + verify_and_bridge_out( + latest_only, + token_bridge_state, + token_chain, + token_address, + recipient_chain, + amount + ); + + let recipient = external_address::to_address(recipient); + + // If the recipient did not redeem his own transfer, Token Bridge will + // split the withdrawn coins and send a portion to the transaction + // relayer. + let payout = if ( + normalized_amount::value(&relayer_fee) == 0 || + recipient == tx_context::sender(ctx) + ) { + balance::zero() + } else { + let payout_amount = + normalized_amount::to_raw( + relayer_fee, + token_registry::coin_decimals(&asset_info) + ); + balance::split(&mut bridged_out, payout_amount) + }; + + // Transfer tokens to the recipient. + sui::transfer::public_transfer( + coin::from_balance(bridged_out, ctx), + recipient + ); + + // Finally produce the receipt that a relayer can consume via + // `redeem_relayer_payout`. + RelayerReceipt { + payout: coin::from_balance(payout, ctx) + } + } + + #[test_only] + public fun burn(receipt: RelayerReceipt) { + coin::burn_for_testing(redeem_relayer_payout(receipt)); + } +} + +#[test_only] +module token_bridge::complete_transfer_tests { + use sui::coin::{Self, Coin}; + use sui::test_scenario::{Self}; + use wormhole::state::{chain_id}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + use token_bridge::coin_wrapped_12::{Self, COIN_WRAPPED_12}; + use token_bridge::coin_wrapped_7::{Self, COIN_WRAPPED_7}; + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::coin_native_4::{Self, COIN_NATIVE_4}; + use token_bridge::complete_transfer::{Self}; + use token_bridge::dummy_message::{Self}; + use token_bridge::native_asset::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + set_up_wormhole_and_token_bridge, + register_dummy_emitter, + return_state, + take_state, + three_people, + two_people + }; + use token_bridge::token_registry::{Self}; + use token_bridge::transfer::{Self}; + use token_bridge::vaa::{Self}; + use token_bridge::wrapped_asset::{Self}; + + struct OTHER_COIN_WITNESS has drop {} + + #[test] + /// An end-to-end test for complete transfer native with VAA. + fun test_complete_transfer_native_10_relayer_fee() { + use token_bridge::complete_transfer::{ + authorize_transfer, + redeem_relayer_payout + }; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_native_with_fee(); + + let (expected_recipient, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + let custody_amount = 500000; + coin_native_10::init_register_and_deposit( + scenario, + coin_deployer, + custody_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + // These will be checked later. + let expected_relayer_fee = 100000; + let expected_recipient_amount = 200000; + let expected_amount = expected_relayer_fee + expected_recipient_amount; + + // Scope to allow immutable reference to `TokenRegistry`. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == custody_amount, 0); + + // Verify transfer parameters. + let parsed = + transfer::deserialize_test_only( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + + let asset_info = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&asset_info); + let expected_token_address = + token_registry::token_address(&asset_info); + assert!(transfer::token_chain(&parsed) == expected_token_chain, 0); + assert!( + transfer::token_address(&parsed) == expected_token_address, + 0 + ); + + let coin_meta = test_scenario::take_shared(scenario); + + let decimals = coin::get_decimals(&coin_meta); + + test_scenario::return_shared(coin_meta); + + assert!( + transfer::raw_amount(&parsed, decimals) == expected_amount, + 0 + ); + + assert!( + transfer::raw_relayer_fee(&parsed, decimals) == expected_relayer_fee, + 0 + ); + assert!( + transfer::recipient_as_address(&parsed) == expected_recipient, + 0 + ); + assert!(transfer::recipient_chain(&parsed) == chain_id(), 0); + + // Clean up. + transfer::destroy(parsed); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let payout = redeem_relayer_payout(receipt); + assert!(coin::value(&payout) == expected_relayer_fee, 0); + + // TODO: Check for one event? `TransferRedeemed`. + let _effects = test_scenario::next_tx(scenario, tx_relayer); + + // Check recipient's `Coin`. + let received = + test_scenario::take_from_address>( + scenario, + expected_recipient + ); + assert!(coin::value(&received) == expected_recipient_amount, 0); + + // And check remaining amount in custody. + let registry = state::borrow_token_registry(&token_bridge_state); + let remaining = custody_amount - expected_amount; + { + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == remaining, 0); + }; + + // Clean up. + coin::burn_for_testing(payout); + coin::burn_for_testing(received); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// An end-to-end test for complete transfer native with VAA. + fun test_complete_transfer_native_4_relayer_fee() { + use token_bridge::complete_transfer::{ + authorize_transfer, + redeem_relayer_payout + }; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_native_with_fee(); + + let (expected_recipient, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + let custody_amount = 5000; + coin_native_4::init_register_and_deposit( + scenario, + coin_deployer, + custody_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + // These will be checked later. + let expected_relayer_fee = 1000; + let expected_recipient_amount = 2000; + let expected_amount = expected_relayer_fee + expected_recipient_amount; + + // Scope to allow immutable reference to `TokenRegistry`. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == custody_amount, 0); + + // Verify transfer parameters. + let parsed = + transfer::deserialize_test_only( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + + let asset_info = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&asset_info); + let expected_token_address = + token_registry::token_address(&asset_info); + assert!(transfer::token_chain(&parsed) == expected_token_chain, 0); + assert!( + transfer::token_address(&parsed) == expected_token_address, + 0 + ); + + let coin_meta = test_scenario::take_shared(scenario); + let decimals = coin::get_decimals(&coin_meta); + test_scenario::return_shared(coin_meta); + + assert!( + transfer::raw_amount(&parsed, decimals) == expected_amount, + 0 + ); + + assert!( + transfer::raw_relayer_fee(&parsed, decimals) == expected_relayer_fee, + 0 + ); + assert!( + transfer::recipient_as_address(&parsed) == expected_recipient, + 0 + ); + assert!(transfer::recipient_chain(&parsed) == chain_id(), 0); + + // Clean up. + transfer::destroy(parsed); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let payout = redeem_relayer_payout(receipt); + assert!(coin::value(&payout) == expected_relayer_fee, 0); + + // TODO: Check for one event? `TransferRedeemed`. + let _effects = test_scenario::next_tx(scenario, tx_relayer); + + // Check recipient's `Coin`. + let received = + test_scenario::take_from_address>( + scenario, + expected_recipient + ); + assert!(coin::value(&received) == expected_recipient_amount, 0); + + // And check remaining amount in custody. + let registry = state::borrow_token_registry(&token_bridge_state); + let remaining = custody_amount - expected_amount; + { + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == remaining, 0); + }; + + // Clean up. + coin::burn_for_testing(payout); + coin::burn_for_testing(received); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// An end-to-end test for complete transfer wrapped with VAA. + fun test_complete_transfer_wrapped_7_relayer_fee() { + use token_bridge::complete_transfer::{ + authorize_transfer, + redeem_relayer_payout + }; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_wrapped_7_with_fee(); + + let (expected_recipient, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + coin_wrapped_7::init_and_register(scenario, coin_deployer); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + // These will be checked later. + let expected_relayer_fee = 1000; + let expected_recipient_amount = 2000; + let expected_amount = expected_relayer_fee + expected_recipient_amount; + + // Scope to allow immutable reference to `TokenRegistry`. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == 0, 0); + + // Verify transfer parameters. + let parsed = + transfer::deserialize_test_only( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + + let asset_info = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&asset_info); + let expected_token_address = + token_registry::token_address(&asset_info); + assert!(transfer::token_chain(&parsed) == expected_token_chain, 0); + assert!( + transfer::token_address(&parsed) == expected_token_address, + 0 + ); + + let coin_meta = test_scenario::take_shared(scenario); + let decimals = coin::get_decimals(&coin_meta); + test_scenario::return_shared(coin_meta); + + assert!( + transfer::raw_amount(&parsed, decimals) == expected_amount, + 0 + ); + + assert!( + transfer::raw_relayer_fee(&parsed, decimals) == expected_relayer_fee, + 0 + ); + assert!( + transfer::recipient_as_address(&parsed) == expected_recipient, + 0 + ); + assert!(transfer::recipient_chain(&parsed) == chain_id(), 0); + + // Clean up. + transfer::destroy(parsed); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let payout = redeem_relayer_payout(receipt); + assert!(coin::value(&payout) == expected_relayer_fee, 0); + + // TODO: Check for one event? `TransferRedeemed`. + let _effects = test_scenario::next_tx(scenario, tx_relayer); + + // Check recipient's `Coin`. + let received = + test_scenario::take_from_address>( + scenario, + expected_recipient + ); + assert!(coin::value(&received) == expected_recipient_amount, 0); + + // And check that the amount is the total wrapped supply. + let registry = state::borrow_token_registry(&token_bridge_state); + { + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == expected_amount, 0); + }; + + // Clean up. + coin::burn_for_testing(payout); + coin::burn_for_testing(received); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// An end-to-end test for complete transfer wrapped with VAA. + fun test_complete_transfer_wrapped_12_relayer_fee() { + use token_bridge::complete_transfer::{ + authorize_transfer, + redeem_relayer_payout + }; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_wrapped_12_with_fee(); + + let (expected_recipient, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + coin_wrapped_12::init_and_register(scenario, coin_deployer); + + // Ignore effects. + // + // NOTE: `tx_relayer` != `expected_recipient`. + assert!(expected_recipient != tx_relayer, 0); + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + // These will be checked later. + let expected_relayer_fee = 1000; + let expected_recipient_amount = 2000; + let expected_amount = expected_relayer_fee + expected_recipient_amount; + + // Scope to allow immutable reference to `TokenRegistry`. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == 0, 0); + + // Verify transfer parameters. + let parsed = + transfer::deserialize_test_only( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + + let asset_info = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&asset_info); + let expected_token_address = + token_registry::token_address(&asset_info); + assert!(transfer::token_chain(&parsed) == expected_token_chain, 0); + assert!(transfer::token_address(&parsed) == expected_token_address, 0); + + let coin_meta = test_scenario::take_shared(scenario); + let decimals = coin::get_decimals(&coin_meta); + test_scenario::return_shared(coin_meta); + + assert!(transfer::raw_amount(&parsed, decimals) == expected_amount, 0); + + assert!( + transfer::raw_relayer_fee(&parsed, decimals) == expected_relayer_fee, + 0 + ); + assert!( + transfer::recipient_as_address(&parsed) == expected_recipient, + 0 + ); + assert!(transfer::recipient_chain(&parsed) == chain_id(), 0); + + // Clean up. + transfer::destroy(parsed); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let payout = redeem_relayer_payout(receipt); + assert!(coin::value(&payout) == expected_relayer_fee, 0); + + // TODO: Check for one event? `TransferRedeemed`. + let _effects = test_scenario::next_tx(scenario, tx_relayer); + + // Check recipient's `Coin`. + let received = + test_scenario::take_from_address>( + scenario, + expected_recipient + ); + assert!(coin::value(&received) == expected_recipient_amount, 0); + + // And check that the amount is the total wrapped supply. + let registry = state::borrow_token_registry(&token_bridge_state); + { + let asset = token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == expected_amount, 0); + }; + + // Clean up. + coin::burn_for_testing(payout); + coin::burn_for_testing(received); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// An end-to-end test for complete transfer native with VAA. The encoded VAA + /// specifies a nonzero fee, however the `recipient` should receive the full + /// amount for self redeeming the transfer. + fun test_complete_transfer_native_10_relayer_fee_self_redemption() { + use token_bridge::complete_transfer::{ + authorize_transfer, + redeem_relayer_payout + }; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_native_with_fee(); + + let (expected_recipient, _, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(expected_recipient); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + let custody_amount = 500000; + coin_native_10::init_register_and_deposit( + scenario, + coin_deployer, + custody_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, expected_recipient); + + let token_bridge_state = take_state(scenario); + + // NOTE: Although there is a fee encoded in the VAA, the relayer + // shouldn't receive this fee. The `expected_relayer_fee` should + // go to the recipient. + // + // These values will be used later. + let expected_relayer_fee = 0; + let encoded_relayer_fee = 100000; + let expected_recipient_amount = 300000; + let expected_amount = expected_relayer_fee + expected_recipient_amount; + + // Scope to allow immutable reference to `TokenRegistry`. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == custody_amount, 0); + + // Verify transfer parameters. + let parsed = + transfer::deserialize_test_only( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + + let asset_info = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&asset_info); + let expected_token_address = + token_registry::token_address(&asset_info); + assert!(transfer::token_chain(&parsed) == expected_token_chain, 0); + assert!(transfer::token_address(&parsed) == expected_token_address, 0); + + let coin_meta = test_scenario::take_shared(scenario); + + let decimals = coin::get_decimals(&coin_meta); + + test_scenario::return_shared(coin_meta); + + assert!(transfer::raw_amount(&parsed, decimals) == expected_amount, 0); + assert!( + transfer::raw_relayer_fee(&parsed, decimals) == encoded_relayer_fee, + 0 + ); + assert!( + transfer::recipient_as_address(&parsed) == expected_recipient, + 0 + ); + assert!(transfer::recipient_chain(&parsed) == chain_id(), 0); + + // Clean up. + transfer::destroy(parsed); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, expected_recipient); + + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let payout = redeem_relayer_payout(receipt); + assert!(coin::value(&payout) == expected_relayer_fee, 0); + + // TODO: Check for one event? `TransferRedeemed`. + let _effects = test_scenario::next_tx(scenario, expected_recipient); + + // Check recipient's `Coin`. + let received = + test_scenario::take_from_address>( + scenario, + expected_recipient + ); + assert!(coin::value(&received) == expected_recipient_amount, 0); + + // And check remaining amount in custody. + let registry = state::borrow_token_registry(&token_bridge_state); + let remaining = custody_amount - expected_amount; + { + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == remaining, 0); + }; + + // Clean up. + coin::burn_for_testing(payout); + coin::burn_for_testing(received); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure( + abort_code = complete_transfer::E_CANONICAL_TOKEN_INFO_MISMATCH + )] + /// This test verifies that `authorize_transfer` reverts when called with + /// a native COIN_TYPE that's not encoded in the VAA. + fun test_cannot_authorize_transfer_native_invalid_coin_type() { + use token_bridge::complete_transfer::{authorize_transfer}; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_native_with_fee(); + + let (_, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + let custody_amount_coin_10 = 500000; + coin_native_10::init_register_and_deposit( + scenario, + coin_deployer, + custody_amount_coin_10 + ); + + // Register a second native asset. + let custody_amount_coin_4 = 69420; + coin_native_4::init_register_and_deposit( + scenario, + coin_deployer, + custody_amount_coin_4 + ); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + // Scope to allow immutable reference to `TokenRegistry`. This verifies + // that both coin types have been registered. + { + let registry = state::borrow_token_registry(&token_bridge_state); + + // COIN_10. + let coin_10 = + token_registry::borrow_native(registry); + assert!( + native_asset::custody(coin_10) == custody_amount_coin_10, + 0 + ); + + // COIN_4. + let coin_4 = token_registry::borrow_native(registry); + assert!(native_asset::custody(coin_4) == custody_amount_coin_4, 0); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + // NOTE: this call should revert since the transfer VAA is for + // a coin of type COIN_NATIVE_10. However, the `complete_transfer` + // method is called using the COIN_NATIVE_4 type. + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + complete_transfer::burn(receipt); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = complete_transfer::E_CANONICAL_TOKEN_INFO_MISMATCH + )] + /// This test verifies that `authorize_transfer` reverts when called with + /// a wrapped COIN_TYPE that's not encoded in the VAA. + fun test_cannot_authorize_transfer_wrapped_invalid_coin_type() { + use token_bridge::complete_transfer::{authorize_transfer}; + + let transfer_vaa = dummy_message::encoded_transfer_vaa_wrapped_12_with_fee(); + + let (expected_recipient, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Register both wrapped coin types (12 and 7). + coin_wrapped_12::init_and_register(scenario, coin_deployer); + coin_wrapped_7::init_and_register(scenario, coin_deployer); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + // NOTE: `tx_relayer` != `expected_recipient`. + assert!(expected_recipient != tx_relayer, 0); + + let token_bridge_state = take_state(scenario); + + // Scope to allow immutable reference to `TokenRegistry`. This verifies + // that both coin types have been registered. + { + let registry = state::borrow_token_registry(&token_bridge_state); + + let coin_12 = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(coin_12) == 0, 0); + + let coin_7 = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(coin_7) == 0, 0); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + // NOTE: this call should revert since the transfer VAA is for + // a coin of type COIN_WRAPPED_12. However, the `authorize_transfer` + // method is called using the COIN_WRAPPED_7 type. + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + complete_transfer::burn(receipt); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = complete_transfer::E_TARGET_NOT_SUI)] + /// This test verifies that `authorize_transfer` reverts when a transfer is + /// sent to the wrong target blockchain (chain ID != 21). + fun test_cannot_authorize_transfer_wrapped_12_invalid_target_chain() { + use token_bridge::complete_transfer::{authorize_transfer}; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_wrapped_12_invalid_target_chain(); + + let (expected_recipient, tx_relayer, coin_deployer) = three_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + coin_wrapped_12::init_and_register(scenario, coin_deployer); + + // Ignore effects. + // + // NOTE: `tx_relayer` != `expected_recipient`. + assert!(expected_recipient != tx_relayer, 0); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + // NOTE: this call should revert since the target chain encoded is + // chain 69 instead of chain 21 (Sui). + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + complete_transfer::burn(receipt); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_complete_transfer_outdated_version() { + use token_bridge::complete_transfer::{authorize_transfer}; + + let transfer_vaa = + dummy_message::encoded_transfer_vaa_native_with_fee(); + + let (tx_relayer, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(tx_relayer); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + let custody_amount = 500000; + coin_native_10::init_register_and_deposit( + scenario, + coin_deployer, + custody_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, tx_relayer); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + complete_transfer::burn(receipt); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/complete_transfer_with_payload.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/complete_transfer_with_payload.move new file mode 100644 index 0000000000..ba35a7a9e8 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/complete_transfer_with_payload.move @@ -0,0 +1,776 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements two methods: `authorize_transfer` and `redeem_coin`, +/// which are to be executed in a transaction block in this order. +/// +/// `authorize_transfer` allows a contract to complete a Token Bridge transfer +/// with arbitrary payload. This deserialized `TransferWithPayload` with the +/// bridged balance and source chain ID are packaged in a `RedeemerReceipt`. +/// +/// `redeem_coin` unpacks the `RedeemerReceipt` and checks whether the specified +/// `EmitterCap` is the specified redeemer for this transfer. If he is the +/// correct redeemer, the balance is unpacked and transformed into `Coin` and +/// is returned alongside `TransferWithPayload` and source chain ID. +/// +/// The purpose of splitting this transfer redemption into two steps is in case +/// Token Bridge needs to be upgraded and there is a breaking change for this +/// module, an integrator would not be left broken. It is discouraged to put +/// `authorize_transfer` in an integrator's package logic. Otherwise, this +/// integrator needs to be prepared to upgrade his contract to handle the latest +/// version of `complete_transfer_with_payload`. +/// +/// Instead, an integrator is encouraged to execute a transaction block, which +/// executes `authorize_transfer` using the latest Token Bridge package ID and +/// to implement `redeem_coin` in his contract to consume this receipt. This is +/// similar to how an integrator with Wormhole is not meant to use +/// `vaa::parse_and_verify` in his contract in case the `vaa` module needs to +/// be upgraded due to a breaking change. +/// +/// Like in `complete_transfer`, a VAA with an encoded transfer can be redeemed +/// only once. +/// +/// See `transfer_with_payload` module for serialization and deserialization of +/// Wormhole message payload. +module token_bridge::complete_transfer_with_payload { + use sui::coin::{Self, Coin}; + use sui::object::{Self}; + use sui::tx_context::{TxContext}; + use wormhole::emitter::{EmitterCap}; + + use token_bridge::complete_transfer::{Self}; + use token_bridge::state::{Self, State, LatestOnly}; + use token_bridge::transfer_with_payload::{Self, TransferWithPayload}; + use token_bridge::vaa::{Self, TokenBridgeMessage}; + + /// `EmitterCap` address does not agree with encoded redeemer. + const E_INVALID_REDEEMER: u64 = 0; + + #[allow(lint(coin_field))] + /// This type is only generated from `authorize_transfer` and can only be + /// redeemed using `redeem_coin`. Integrators are expected to implement + /// `redeem_coin` within their contracts and call `authorize_transfer` in a + /// transaction block preceding the method that consumes this receipt. The + /// only way to destroy this receipt is calling `redeem_coin` with an + /// `EmitterCap` generated from the `wormhole::emitter` module, whose ID is + /// the expected redeemer for this token transfer. + struct RedeemerReceipt { + /// Which chain ID this transfer originated from. + source_chain: u16, + /// Deserialized transfer info. + parsed: TransferWithPayload, + /// Coin of bridged asset. + bridged_out: Coin + } + + /// `authorize_transfer` deserializes a token transfer VAA payload, which + /// encodes its own arbitrary payload (which has meaning to the redeemer). + /// Once the transfer is authorized, an event (`TransferRedeemed`) is + /// emitted to reflect which Token Bridge this transfer originated from. + /// The `RedeemerReceipt` returned wraps a balance reflecting the encoded + /// transfer amount along with the source chain and deserialized + /// `TransferWithPayload`. + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + /// + /// It is important for integrators to refrain from calling this method + /// within their contracts. This method is meant to be called in a + /// transaction block, passing the `RedeemerReceipt` to a method which calls + /// `redeem_coin` within a contract. If in a circumstance where this module + /// has a breaking change in an upgrade, `redeem_coin` will not be affected + /// by this change. + /// + /// See `redeem_coin` for more details. + public fun authorize_transfer( + token_bridge_state: &mut State, + msg: TokenBridgeMessage, + ctx: &mut TxContext + ): RedeemerReceipt { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // Emitting the transfer being redeemed. + // + // NOTE: We save the emitter chain ID to save the integrator from + // having to `parse_and_verify` the same encoded VAA to get this info. + let source_chain = + complete_transfer::emit_transfer_redeemed(&msg); + + // Finally deserialize the Wormhole message payload and handle bridging + // out token of a given coin type. + handle_authorize_transfer( + &latest_only, + token_bridge_state, + source_chain, + vaa::take_payload(msg), + ctx + ) + } + + /// After a transfer is authorized, only a valid redeemer may unpack the + /// `RedeemerReceipt`. The specified `EmitterCap` is the only authorized + /// redeemer of the transfer. Once the redeemer is validated, coin from + /// this receipt of the specified coin type is returned alongside the + /// deserialized `TransferWithPayload` and source chain ID. + /// + /// NOTE: Integrators of Token Bridge redeeming these token transfers should + /// be calling only this method from their contracts. This method is not + /// guarded by version control (thus not requiring a reference to the + /// Token Bridge `State` object), so it is intended to work for any package + /// version. + public fun redeem_coin( + emitter_cap: &EmitterCap, + receipt: RedeemerReceipt + ): ( + Coin, + TransferWithPayload, + u16 // `wormhole::vaa::emitter_chain` + ) { + let RedeemerReceipt { source_chain, parsed, bridged_out } = receipt; + + // Transfer must be redeemed by the contract's registered Wormhole + // emitter. + let redeemer = transfer_with_payload::redeemer_id(&parsed); + assert!(redeemer == object::id(emitter_cap), E_INVALID_REDEEMER); + + // Create coin from balance and return other unpacked members of receipt. + (bridged_out, parsed, source_chain) + } + + fun handle_authorize_transfer( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + source_chain: u16, + transfer_vaa_payload: vector, + ctx: &mut TxContext + ): RedeemerReceipt { + // Deserialize for processing. + let parsed = transfer_with_payload::deserialize(transfer_vaa_payload); + + // Handle bridging assets out to be returned to method caller. + // + // See `complete_transfer` module for more info. + let ( + _, + bridged_out, + ) = + complete_transfer::verify_and_bridge_out( + latest_only, + token_bridge_state, + transfer_with_payload::token_chain(&parsed), + transfer_with_payload::token_address(&parsed), + transfer_with_payload::redeemer_chain(&parsed), + transfer_with_payload::amount(&parsed) + ); + + RedeemerReceipt { + source_chain, + parsed, + bridged_out: coin::from_balance(bridged_out, ctx) + } + } + + #[test_only] + public fun burn(receipt: RedeemerReceipt) { + let RedeemerReceipt { + source_chain: _, + parsed: _, + bridged_out + } = receipt; + coin::burn_for_testing(bridged_out); + } +} + +#[test_only] +module token_bridge::complete_transfer_with_payload_tests { + use sui::coin::{Self}; + use sui::object::{Self}; + use sui::test_scenario::{Self}; + use wormhole::emitter::{Self}; + use wormhole::state::{chain_id}; + use wormhole::wormhole_scenario::{new_emitter, parse_and_verify_vaa}; + + use token_bridge::coin_wrapped_12::{Self, COIN_WRAPPED_12}; + use token_bridge::complete_transfer_with_payload::{Self}; + use token_bridge::complete_transfer::{Self}; + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::dummy_message::{Self}; + use token_bridge::native_asset::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + register_dummy_emitter, + return_state, + set_up_wormhole_and_token_bridge, + take_state, + two_people + }; + use token_bridge::token_registry::{Self}; + use token_bridge::transfer_with_payload::{Self}; + use token_bridge::vaa::{Self}; + use token_bridge::wrapped_asset::{Self}; + + #[test] + /// Test the public-facing function authorize_transfer. + /// using a native transfer VAA_ATTESTED_DECIMALS_10. + fun test_complete_transfer_with_payload_native_asset() { + use token_bridge::complete_transfer_with_payload::{ + authorize_transfer, + redeem_coin + }; + + let transfer_vaa = + dummy_message::encoded_transfer_with_payload_vaa_native(); + + let (user, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register Sui as a foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Initialize native token. + let mint_amount = 1000000; + coin_native_10::init_register_and_deposit( + scenario, + coin_deployer, + mint_amount + ); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + { + let asset = token_registry::borrow_native( + state::borrow_token_registry(&token_bridge_state) + ); + assert!(native_asset::custody(asset) == mint_amount, 0); + }; + + // Set up dummy `EmitterCap` as the expected redeemer. + let emitter_cap = emitter::dummy(); + + // Verify that the emitter cap is the expected redeemer. + let expected_transfer = + transfer_with_payload::deserialize( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + assert!( + transfer_with_payload::redeemer_id(&expected_transfer) == object::id(&emitter_cap), + 0 + ); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + // Execute authorize_transfer. + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let ( + bridged, + parsed_transfer, + source_chain + ) = redeem_coin(&emitter_cap, receipt); + + assert!(source_chain == expected_source_chain, 0); + + // Assert coin value, source chain, and parsed transfer details are correct. + // We expect the coin value to be 300000, because that's in terms of + // 10 decimals. The amount specified in the VAA_ATTESTED_DECIMALS_12 is 3000, because that's + // in terms of 8 decimals. + let expected_bridged = 300000; + assert!(coin::value(&bridged) == expected_bridged, 0); + + // Amount left on custody should be whatever is left remaining after + // the transfer. + let remaining = mint_amount - expected_bridged; + { + let asset = token_registry::borrow_native( + state::borrow_token_registry(&token_bridge_state) + ); + assert!(native_asset::custody(asset) == remaining, 0); + }; + + // Verify token info. + let registry = state::borrow_token_registry(&token_bridge_state); + let verified = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&verified); + let expected_token_address = token_registry::token_address(&verified); + assert!(expected_token_chain == chain_id(), 0); + assert!( + transfer_with_payload::token_chain(&parsed_transfer) == expected_token_chain, + 0 + ); + assert!( + transfer_with_payload::token_address(&parsed_transfer) == expected_token_address, + 0 + ); + + // Verify transfer by serializing both parsed and expected. + let serialized = transfer_with_payload::serialize(parsed_transfer); + let expected_serialized = + transfer_with_payload::serialize(expected_transfer); + assert!(serialized == expected_serialized, 0); + + // Clean up. + return_state(token_bridge_state); + coin::burn_for_testing(bridged); + emitter::destroy_test_only(emitter_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// Test the public-facing functions `authorize_transfer` and `redeem_coin`. + /// Use an actual devnet Wormhole complete transfer with payload + /// VAA_ATTESTED_DECIMALS_12. + /// + /// This test confirms that: + /// - `authorize_transfer` with `redeem_coin` deserializes the encoded + /// transfer and recovers the source chain, payload, and additional + /// transfer details wrapped in a redeemer receipt. + /// - a wrapped coin with the correct value is minted by the bridge + /// and returned by authorize_transfer + /// + fun test_complete_transfer_with_payload_wrapped_asset() { + use token_bridge::complete_transfer_with_payload::{ + authorize_transfer, + redeem_coin + }; + + let transfer_vaa = + dummy_message::encoded_transfer_with_payload_wrapped_12(); + + let (user, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register chain ID 2 as a foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Register wrapped token. + coin_wrapped_12::init_and_register(scenario, coin_deployer); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + // Set up dummy `EmitterCap` as the expected redeemer. + let emitter_cap = emitter::dummy(); + + // Verify that the emitter cap is the expected redeemer. + let expected_transfer = + transfer_with_payload::deserialize( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + assert!( + transfer_with_payload::redeemer_id(&expected_transfer) == object::id(&emitter_cap), + 0 + ); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + // Execute authorize_transfer. + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + let ( + bridged, + parsed_transfer, + source_chain + ) = redeem_coin(&emitter_cap, receipt); + assert!(source_chain == expected_source_chain, 0); + + // Assert coin value, source chain, and parsed transfer details are correct. + let expected_bridged = 3000; + assert!(coin::value(&bridged) == expected_bridged, 0); + + // Total supply should equal the amount just minted. + let registry = state::borrow_token_registry(&token_bridge_state); + { + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == expected_bridged, 0); + }; + + // Verify token info. + let verified = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&verified); + let expected_token_address = token_registry::token_address(&verified); + assert!(expected_token_chain != chain_id(), 0); + assert!( + transfer_with_payload::token_chain(&parsed_transfer) == expected_token_chain, + 0 + ); + assert!( + transfer_with_payload::token_address(&parsed_transfer) == expected_token_address, + 0 + ); + + // Verify transfer by serializing both parsed and expected. + let serialized = transfer_with_payload::serialize(parsed_transfer); + let expected_serialized = + transfer_with_payload::serialize(expected_transfer); + assert!(serialized == expected_serialized, 0); + + // Clean up. + return_state(token_bridge_state); + coin::burn_for_testing(bridged); + emitter::destroy_test_only(emitter_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure( + abort_code = complete_transfer_with_payload::E_INVALID_REDEEMER, + )] + /// Test the public-facing function authorize_transfer. + /// This test fails because the ecmitter_cap (recipient) is incorrect (0x2 instead of 0x3). + /// + fun test_cannot_complete_transfer_with_payload_invalid_redeemer() { + use token_bridge::complete_transfer_with_payload::{ + authorize_transfer, + redeem_coin + }; + + let transfer_vaa = + dummy_message::encoded_transfer_with_payload_wrapped_12(); + + let (user, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register chain ID 2 as a foreign emitter. + register_dummy_emitter(scenario, 2); + + // Register wrapped asset with 12 decimals. + coin_wrapped_12::init_and_register(scenario, coin_deployer); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + let parsed = + transfer_with_payload::deserialize( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + + // Because the vaa expects the dummy emitter as the redeemer, we need + // to generate another emitter. + let emitter_cap = new_emitter(scenario); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + assert!( + transfer_with_payload::redeemer_id(&parsed) != object::id(&emitter_cap), + 0 + ); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + // You shall not pass! + let ( + bridged_out, + _, + _ + ) = redeem_coin(&emitter_cap, receipt); + + // Clean up. + coin::burn_for_testing(bridged_out); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = complete_transfer::E_CANONICAL_TOKEN_INFO_MISMATCH + )] + /// This test demonstrates that the `CoinType` specified for the token + /// redemption must agree with the canonical token info encoded in the VAA_ATTESTED_DECIMALS_12, + /// which is registered with the Token Bridge. + fun test_cannot_complete_transfer_with_payload_wrong_coin_type() { + use token_bridge::complete_transfer_with_payload::{ + authorize_transfer + }; + + let transfer_vaa = + dummy_message::encoded_transfer_with_payload_wrapped_12(); + + let (user, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register chain ID 2 as a foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Register wrapped token. + coin_wrapped_12::init_and_register(scenario, coin_deployer); + + // Also register unexpected token (in this case a native one). + coin_native_10::init_and_register(scenario, coin_deployer); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + let registry = state::borrow_token_registry(&token_bridge_state); + + // Set up dummy `EmitterCap` as the expected redeemer. + let emitter_cap = emitter::dummy(); + + // Verify that the emitter cap is the expected redeemer. + let expected_transfer = + transfer_with_payload::deserialize( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + assert!( + transfer_with_payload::redeemer_id(&expected_transfer) == object::id(&emitter_cap), + 0 + ); + + // Also verify that the encoded token info disagrees with the expected + // token info. + let verified = + token_registry::verified_asset(registry); + let expected_token_chain = token_registry::token_chain(&verified); + let expected_token_address = token_registry::token_address(&verified); + assert!( + transfer_with_payload::token_chain(&expected_transfer) != expected_token_chain, + 0 + ); + assert!( + transfer_with_payload::token_address(&expected_transfer) != expected_token_address, + 0 + ); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + // You shall not pass! + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + return_state(token_bridge_state); + complete_transfer_with_payload::burn(receipt); + emitter::destroy_test_only(emitter_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = complete_transfer::E_TARGET_NOT_SUI)] + /// This test verifies that `complete_transfer` reverts when a transfer is + /// sent to the wrong target blockchain (chain ID != 21). + fun test_cannot_complete_transfer_with_payload_wrapped_asset_invalid_target_chain() { + use token_bridge::complete_transfer_with_payload::{ + authorize_transfer + }; + + let transfer_vaa = + dummy_message::encoded_transfer_with_payload_wrapped_12_invalid_target_chain(); + + let (user, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register chain ID 2 as a foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Register wrapped token. + coin_wrapped_12::init_and_register(scenario, coin_deployer); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + // Set up dummy `EmitterCap` as the expected redeemer. + let emitter_cap = emitter::dummy(); + + // Verify that the emitter cap is the expected redeemer. + let expected_transfer = + transfer_with_payload::deserialize( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + assert!( + transfer_with_payload::redeemer_id(&expected_transfer) == object::id(&emitter_cap), + 0 + ); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + // You shall not pass! + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + complete_transfer_with_payload::burn(receipt); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_complete_transfer_with_payload_outdated_version() { + use token_bridge::complete_transfer_with_payload::{authorize_transfer}; + + let transfer_vaa = + dummy_message::encoded_transfer_with_payload_vaa_native(); + + let (user, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register Sui as a foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Initialize native token. + let mint_amount = 1000000; + coin_native_10::init_register_and_deposit( + scenario, + coin_deployer, + mint_amount + ); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + // Set up dummy `EmitterCap` as the expected redeemer. + let emitter_cap = emitter::dummy(); + + // Verify that the emitter cap is the expected redeemer. + let expected_transfer = + transfer_with_payload::deserialize( + wormhole::vaa::take_payload( + parse_and_verify_vaa(scenario, transfer_vaa) + ) + ); + assert!( + transfer_with_payload::redeemer_id(&expected_transfer) == object::id(&emitter_cap), + 0 + ); + + let verified_vaa = parse_and_verify_vaa(scenario, transfer_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Ignore effects. Begin processing as arbitrary tx executor. + test_scenario::next_tx(scenario, user); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + let receipt = + authorize_transfer( + &mut token_bridge_state, + msg, + test_scenario::ctx(scenario) + ); + + // Clean up. + complete_transfer_with_payload::burn(receipt); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/create_wrapped.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/create_wrapped.move new file mode 100644 index 0000000000..639d170373 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/create_wrapped.move @@ -0,0 +1,643 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements methods that create a specific coin type reflecting a +/// wrapped (foreign) asset, whose metadata is encoded in a VAA sent from +/// another network. +/// +/// Wrapped assets are created in two steps. +/// 1. `prepare_registration`: This method creates a new `TreasuryCap` for a +/// given coin type and wraps an encoded asset metadata VAA. We require a +/// one-time witness (OTW) to throw an explicit error (even though it is +/// redundant with what `create_currency` requires). This coin will +/// be published using this method, meaning the `init` method in that +/// untrusted package will have the asset's decimals hard-coded for its +/// coin metadata. A `WrappedAssetSetup` object is transferred to the +/// transaction sender. +/// 2. `complete_registration`: This method destroys the `WrappedAssetSetup` +/// object by unpacking its `TreasuryCap`, which will be warehoused in the +/// `TokenRegistry`. The shared coin metadata object will be updated to +/// reflect the contents of the encoded asset metadata payload. +/// +/// Wrapped asset metadata can also be updated with a new asset metadata VAA. +/// By calling `update_attestation`, Token Bridge verifies that the specific +/// coin type is registered and agrees with the encoded asset metadata's +/// canonical token info. `ForeignInfo` and the coin's metadata will be updated +/// based on the encoded asset metadata payload. +/// +/// See `state` and `wrapped_asset` modules for more details. +/// +/// References: +/// https://examples.sui.io/basics/one-time-witness.html +module token_bridge::create_wrapped { + use std::ascii::{Self}; + use std::option::{Self}; + use std::type_name::{Self}; + use sui::coin::{Self, TreasuryCap, CoinMetadata}; + use sui::object::{Self, UID}; + use sui::package::{UpgradeCap}; + use sui::transfer::{Self}; + use sui::tx_context::{TxContext}; + + use token_bridge::asset_meta::{Self}; + use token_bridge::normalized_amount::{max_decimals}; + use token_bridge::state::{Self, State}; + use token_bridge::token_registry::{Self}; + use token_bridge::vaa::{Self, TokenBridgeMessage}; + use token_bridge::wrapped_asset::{Self}; + + #[test_only] + use token_bridge::version_control::{Self, V__0_2_0 as V__CURRENT}; + + /// Failed one-time witness verification. + const E_BAD_WITNESS: u64 = 0; + /// Coin witness does not equal "COIN". + const E_INVALID_COIN_MODULE_NAME: u64 = 1; + /// Decimals value exceeds `MAX_DECIMALS` from `normalized_amount`. + const E_DECIMALS_EXCEED_WRAPPED_MAX: u64 = 2; + + /// A.K.A. "coin". + const COIN_MODULE_NAME: vector = b"coin"; + + /// Container holding new coin type's `TreasuryCap` and encoded asset metadata + /// VAA, which are required to complete this asset's registration. + struct WrappedAssetSetup has key, store { + id: UID, + treasury_cap: TreasuryCap + } + + /// This method is executed within the `init` method of an untrusted module, + /// which defines a one-time witness (OTW) type (`CoinType`). OTW is + /// required to ensure that only one `TreasuryCap` exists for `CoinType`. This + /// is similar to how a `TreasuryCap` is created in `coin::create_currency`. + /// + /// Because this method is stateless (i.e. no dependency on Token Bridge's + /// `State` object), the contract defers VAA verification to + /// `complete_registration` after this method has been executed. + public fun prepare_registration( + witness: CoinType, + decimals: u8, + ctx: &mut TxContext + ): WrappedAssetSetup { + let setup = prepare_registration_internal(witness, decimals, ctx); + + // Also make sure that this witness module name is literally "coin". + let module_name = type_name::get_module(&type_name::get()); + assert!( + ascii::into_bytes(module_name) == COIN_MODULE_NAME, + E_INVALID_COIN_MODULE_NAME + ); + + setup + } + + #[allow(lint(share_owned))] + /// This function performs the bulk of `prepare_registration`, except + /// checking the module name. This separation is useful for testing. + fun prepare_registration_internal( + witness: CoinType, + decimals: u8, + ctx: &mut TxContext + ): WrappedAssetSetup { + // Make sure there's only one instance of the type `CoinType`. This + // resembles the same check for `coin::create_currency`. + // Technically this check is redundant as it's performed by + // `coin::create_currency` below, but it doesn't hurt. + assert!(sui::types::is_one_time_witness(&witness), E_BAD_WITNESS); + + // Ensure that the decimals passed into this method do not exceed max + // decimals (see `normalized_amount` module). + assert!(decimals <= max_decimals(), E_DECIMALS_EXCEED_WRAPPED_MAX); + + // We initialise the currency with empty metadata. Later on, in the + // `complete_registration` call, when `CoinType` gets associated with a + // VAA, we update these fields. + let no_symbol = b""; + let no_name = b""; + let no_description = b""; + let no_icon_url = option::none(); + + let (treasury_cap, coin_meta) = + coin::create_currency( + witness, + decimals, + no_symbol, + no_name, + no_description, + no_icon_url, + ctx + ); + + // The CoinMetadata is turned into a shared object so that other + // functions (and wallets) can easily grab references to it. This is + // safe to do, as the metadata setters require a `TreasuryCap` for the + // coin too, which is held by the token bridge. + transfer::public_share_object(coin_meta); + + // Create `WrappedAssetSetup` object and transfer to transaction sender. + // The owner of this object will call `complete_registration` to destroy + // it. + WrappedAssetSetup { + id: object::new(ctx), + treasury_cap + } + } + + /// After executing `prepare_registration`, owner of `WrappedAssetSetup` + /// executes this method to complete this wrapped asset's registration. + /// + /// This method destroys `WrappedAssetSetup`, unpacking the `TreasuryCap` and + /// encoded asset metadata VAA. The deserialized asset metadata VAA is used + /// to update the associated `CoinMetadata`. + public fun complete_registration( + token_bridge_state: &mut State, + coin_meta: &mut CoinMetadata, + setup: WrappedAssetSetup, + coin_upgrade_cap: UpgradeCap, + msg: TokenBridgeMessage + ) { + // This capability ensures that the current build version is used. This + // call performs an additional check of whether `WrappedAssetSetup` was + // created using the current package. + let latest_only = + state::assert_latest_only_specified(token_bridge_state); + + let WrappedAssetSetup { + id, + treasury_cap + } = setup; + + // Finally destroy the object. + object::delete(id); + + // Deserialize to `AssetMeta`. + let token_meta = asset_meta::deserialize(vaa::take_payload(msg)); + + // `register_wrapped_asset` uses `token_registry::add_new_wrapped`, + // which will check whether the asset has already been registered and if + // the token chain ID is not Sui's. + // + // If both of these conditions are met, `register_wrapped_asset` will + // succeed and the new wrapped coin will be registered. + token_registry::add_new_wrapped( + state::borrow_mut_token_registry(&latest_only, token_bridge_state), + token_meta, + coin_meta, + treasury_cap, + coin_upgrade_cap + ); + } + + /// For registered wrapped assets, we can update `ForeignInfo` for a + /// given `CoinType` with a new asset meta VAA emitted from another network. + public fun update_attestation( + token_bridge_state: &mut State, + coin_meta: &mut CoinMetadata, + msg: TokenBridgeMessage + ) { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // Deserialize to `AssetMeta`. + let token_meta = asset_meta::deserialize(vaa::take_payload(msg)); + + // This asset must exist in the registry. + let registry = + state::borrow_mut_token_registry(&latest_only, token_bridge_state); + token_registry::assert_has(registry); + + // Now update wrapped. + wrapped_asset::update_metadata( + token_registry::borrow_mut_wrapped(registry), + coin_meta, + token_meta + ); + } + + public fun incomplete_metadata( + coin_meta: &CoinMetadata + ): bool { + use std::string::{bytes}; + use std::vector::{is_empty}; + + ( + is_empty(ascii::as_bytes(&coin::get_symbol(coin_meta))) && + is_empty(bytes(&coin::get_name(coin_meta))) && + is_empty(bytes(&coin::get_description(coin_meta))) && + std::option::is_none(&coin::get_icon_url(coin_meta)) + ) + } + + #[test_only] + public fun new_setup_test_only( + _version: Version, + witness: CoinType, + decimals: u8, + ctx: &mut TxContext + ): (WrappedAssetSetup, UpgradeCap) { + let setup = + prepare_registration_internal( + witness, + decimals, + ctx + ); + + let upgrade_cap = + sui::package::test_publish( + object::id_from_address(@token_bridge), + ctx + ); + + (setup, upgrade_cap) + } + + #[test_only] + public fun new_setup_current( + witness: CoinType, + decimals: u8, + ctx: &mut TxContext + ): (WrappedAssetSetup, UpgradeCap) { + new_setup_test_only( + version_control::current_version_test_only(), + witness, + decimals, + ctx + ) + } + + #[test_only] + public fun take_treasury_cap( + setup: WrappedAssetSetup + ): TreasuryCap { + let WrappedAssetSetup { + id, + treasury_cap + } = setup; + object::delete(id); + + treasury_cap + } +} + +#[test_only] +module token_bridge::create_wrapped_tests { + use sui::coin::{Self}; + use sui::test_scenario::{Self}; + use sui::test_utils::{Self}; + use sui::tx_context::{Self}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + use token_bridge::asset_meta::{Self}; + use token_bridge::coin_wrapped_12::{Self}; + use token_bridge::coin_wrapped_7::{Self}; + use token_bridge::create_wrapped::{Self}; + use token_bridge::state::{Self}; + use token_bridge::string_utils::{Self}; + use token_bridge::token_bridge_scenario::{ + register_dummy_emitter, + return_state, + set_up_wormhole_and_token_bridge, + take_state, + two_people + }; + use token_bridge::token_registry::{Self}; + use token_bridge::vaa::{Self}; + use token_bridge::version_control::{V__0_2_0 as V__CURRENT}; + use token_bridge::wrapped_asset::{Self}; + + struct NOT_A_WITNESS has drop {} + + struct CREATE_WRAPPED_TESTS has drop {} + + #[test] + #[expected_failure(abort_code = create_wrapped::E_BAD_WITNESS)] + fun test_cannot_prepare_registration_bad_witness() { + let ctx = &mut tx_context::dummy(); + + // You shall not pass! + let wrapped_asset_setup = + create_wrapped::prepare_registration( + NOT_A_WITNESS {}, + 3, + ctx + ); + + // Clean up. + test_utils::destroy(wrapped_asset_setup); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = create_wrapped::E_INVALID_COIN_MODULE_NAME)] + fun test_cannot_prepare_registration_invalid_coin_module_name() { + let ctx = &mut tx_context::dummy(); + + // You shall not pass! + let wrapped_asset_setup = + create_wrapped::prepare_registration< + CREATE_WRAPPED_TESTS, + V__CURRENT + >( + CREATE_WRAPPED_TESTS {}, + 3, + ctx + ); + + // Clean up. + test_utils::destroy(wrapped_asset_setup); + + abort 42 + } + + #[test] + fun test_complete_and_update_attestation() { + let (caller, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. Make sure `coin_deployer` receives + // `WrappedAssetSetup`. + test_scenario::next_tx(scenario, coin_deployer); + + // Publish coin. + let ( + wrapped_asset_setup, + upgrade_cap + ) = + create_wrapped::new_setup_current( + CREATE_WRAPPED_TESTS {}, + 8, + test_scenario::ctx(scenario) + ); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = + parse_and_verify_vaa(scenario, coin_wrapped_12::encoded_vaa()); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + let coin_meta = test_scenario::take_shared(scenario); + + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + wrapped_asset_setup, + upgrade_cap, + msg + ); + + let ( + token_address, + token_chain, + native_decimals, + symbol, + name + ) = asset_meta::unpack_test_only(coin_wrapped_12::token_meta()); + + // Check registry. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let verified = + token_registry::verified_asset(registry); + assert!(token_registry::is_wrapped(&verified), 0); + + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == 0, 0); + + // Decimals are capped for this wrapped asset. + assert!(coin::get_decimals(&coin_meta) == 8, 0); + + // Check metadata against asset metadata. + let info = wrapped_asset::info(asset); + assert!(wrapped_asset::token_chain(info) == token_chain, 0); + assert!(wrapped_asset::token_address(info) == token_address, 0); + assert!( + wrapped_asset::native_decimals(info) == native_decimals, + 0 + ); + assert!(coin::get_symbol(&coin_meta) == string_utils::to_ascii(&symbol), 0); + assert!(coin::get_name(&coin_meta) == name, 0); + }; + + + // Now update metadata. + let verified_vaa = + parse_and_verify_vaa( + scenario, + coin_wrapped_12::encoded_updated_vaa() + ); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + create_wrapped::update_attestation( + &mut token_bridge_state, + &mut coin_meta, + msg + ); + + // Check updated name and symbol. + let ( + _, + _, + _, + new_symbol, + new_name + ) = asset_meta::unpack_test_only(coin_wrapped_12::updated_token_meta()); + + assert!(symbol != new_symbol, 0); + + assert!(coin::get_symbol(&coin_meta) == string_utils::to_ascii(&new_symbol), 0); + + assert!(name != new_name, 0); + assert!(coin::get_name(&coin_meta) == new_name, 0); + + test_scenario::return_shared(coin_meta); + + // Clean up. + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wrapped_asset::E_ASSET_META_MISMATCH)] + fun test_cannot_update_attestation_wrong_canonical_info() { + let (caller, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. Make sure `coin_deployer` receives + // `WrappedAssetSetup`. + test_scenario::next_tx(scenario, coin_deployer); + + // Publish coin. + let ( + wrapped_asset_setup, + upgrade_cap + ) = + create_wrapped::new_setup_current( + CREATE_WRAPPED_TESTS {}, + 8, + test_scenario::ctx(scenario) + ); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = + parse_and_verify_vaa(scenario, coin_wrapped_12::encoded_vaa()); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + let coin_meta = test_scenario::take_shared(scenario); + + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + wrapped_asset_setup, + upgrade_cap, + msg + ); + // This VAA is for COIN_WRAPPED_7 metadata, which disagrees with + // COIN_WRAPPED_12. + let invalid_asset_meta_vaa = coin_wrapped_7::encoded_vaa(); + + let verified_vaa = + parse_and_verify_vaa(scenario, invalid_asset_meta_vaa); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + // You shall not pass! + create_wrapped::update_attestation( + &mut token_bridge_state, + &mut coin_meta, + msg + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = state::E_VERSION_MISMATCH)] + fun test_cannot_complete_registration_version_mismatch() { + let (caller, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. Make sure `coin_deployer` receives + // `WrappedAssetSetup`. + test_scenario::next_tx(scenario, coin_deployer); + + // Publish coin. + let ( + wrapped_asset_setup, + upgrade_cap + ) = + create_wrapped::new_setup_test_only( + token_bridge::version_control::dummy(), + CREATE_WRAPPED_TESTS {}, + 8, + test_scenario::ctx(scenario) + ); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = + parse_and_verify_vaa(scenario, coin_wrapped_12::encoded_vaa()); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + let coin_meta = test_scenario::take_shared(scenario); + + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + wrapped_asset_setup, + upgrade_cap, + msg + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_complete_registration_outdated_version() { + let (caller, coin_deployer) = two_people(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. Make sure `coin_deployer` receives + // `WrappedAssetSetup`. + test_scenario::next_tx(scenario, coin_deployer); + + // Publish coin. + let ( + wrapped_asset_setup, + upgrade_cap + ) = + create_wrapped::new_setup_current( + CREATE_WRAPPED_TESTS {}, + 8, + test_scenario::ctx(scenario) + ); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = + parse_and_verify_vaa(scenario, coin_wrapped_12::encoded_vaa()); + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + let coin_meta = test_scenario::take_shared(scenario); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + wrapped_asset_setup, + upgrade_cap, + msg + ); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/datatypes/normalized_amount.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/datatypes/normalized_amount.move new file mode 100644 index 0000000000..e63d3d296b --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/datatypes/normalized_amount.move @@ -0,0 +1,167 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a container that stores the token transfer amount +/// encoded in a Token Bridge message. These amounts are capped at 8 decimals. +/// This means that any amount of a coin whose metadata defines its decimals +/// as some value greater than 8, the encoded amount will be normalized to +/// eight decimals (which will lead to some residual amount after the transfer). +/// For inbound transfers, this amount will be denormalized (scaled by the same +/// decimal difference). +module token_bridge::normalized_amount { + use sui::math::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Cursor}; + + /// The amounts in the token bridge payload are truncated to 8 decimals + /// in each of the contracts when sending tokens out, so there's no + /// precision beyond 10^-8. We could preserve the original number of + /// decimals when creating wrapped assets, and "untruncate" the amounts + /// on the way out by scaling back appropriately. This is what most + /// other chains do, but untruncating from 8 decimals to 18 decimals + /// loses log2(10^10) ~ 33 bits of precision, which we cannot afford on + /// Aptos (and Solana), as the coin type only has 64bits to begin with. + /// Contrast with Ethereum, where amounts are 256 bits. + /// So we cap the maximum decimals at 8 when creating a wrapped token. + const MAX_DECIMALS: u8 = 8; + + /// Container holding the value decoded from a Token Bridge transfer. + struct NormalizedAmount has store, copy, drop { + value: u64 + } + + public fun max_decimals(): u8 { + MAX_DECIMALS + } + + /// Utility function to cap decimal amount to 8. + public fun cap_decimals(decimals: u8): u8 { + if (decimals > MAX_DECIMALS) { + MAX_DECIMALS + } else { + decimals + } + } + + /// Create new `NormalizedAmount` of zero. + public fun default(): NormalizedAmount { + new(0) + } + + /// Retrieve underlying value. + public fun value(self: &NormalizedAmount): u64 { + self.value + } + + /// Retrieve underlying value as `u256`. + public fun to_u256(norm: NormalizedAmount): u256 { + (take_value(norm) as u256) + } + + /// Create new `NormalizedAmount` using raw amount and specified decimals. + public fun from_raw(amount: u64, decimals: u8): NormalizedAmount { + if (amount == 0) { + default() + } else if (decimals > MAX_DECIMALS) { + new(amount / math::pow(10, decimals - MAX_DECIMALS)) + } else { + new(amount) + } + } + + /// Denormalize `NormalizedAmount` using specified decimals. + public fun to_raw(norm: NormalizedAmount, decimals: u8): u64 { + let value = take_value(norm); + + if (value > 0 && decimals > MAX_DECIMALS) { + value * math::pow(10, decimals - MAX_DECIMALS) + } else { + value + } + } + + /// Transform `NormalizedAmount` to serialized (big-endian) u256. + public fun to_bytes(norm: NormalizedAmount): vector { + bytes32::to_bytes(bytes32::from_u256_be(to_u256(norm))) + } + + /// Read 32 bytes from `Cursor` and deserialize to u64, ensuring no + /// overflow. + public fun take_bytes(cur: &mut Cursor): NormalizedAmount { + // Amounts are encoded with 32 bytes. + new(bytes32::to_u64_be(bytes32::take_bytes(cur))) + } + + fun new(value: u64): NormalizedAmount { + NormalizedAmount { + value + } + } + + fun take_value(norm: NormalizedAmount): u64 { + let NormalizedAmount { value } = norm; + value + } +} + +#[test_only] +module token_bridge::normalized_amount_test { + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + + use token_bridge::normalized_amount::{Self}; + + #[test] + fun test_from_and_to_raw() { + // Use decimals > 8 to check truncation. + let decimals = 9; + let raw_amount = 12345678910111; + let normalized = normalized_amount::from_raw(raw_amount, decimals); + let denormalized = normalized_amount::to_raw(normalized, decimals); + assert!(denormalized == 10 * (raw_amount / 10), 0); + + // Use decimals <= 8 to check raw amount recovery. + let decimals = 5; + let normalized = normalized_amount::from_raw(raw_amount, decimals); + let denormalized = normalized_amount::to_raw(normalized, decimals); + assert!(denormalized == raw_amount, 0); + } + + #[test] + fun test_take_bytes() { + let cur = + cursor::new( + x"000000000000000000000000000000000000000000000000ffffffffffffffff" + ); + + let norm = normalized_amount::take_bytes(&mut cur); + assert!( + normalized_amount::value(&norm) == ((1u256 << 64) - 1 as u64), + 0 + ); + + // Clean up. + cursor::destroy_empty(cur); + } + + #[test] + #[expected_failure(abort_code = wormhole::bytes32::E_U64_OVERFLOW)] + fun test_cannot_take_bytes_overflow() { + let encoded_overflow = + x"0000000000000000000000000000000000000000000000010000000000000000"; + + let amount = { + let cur = cursor::new(encoded_overflow); + let value = bytes::take_u256_be(&mut cur); + cursor::destroy_empty(cur); + value + }; + assert!(amount == (1 << 64), 0); + + let cur = cursor::new(encoded_overflow); + + // You shall not pass! + normalized_amount::take_bytes(&mut cur); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/governance/register_chain.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/governance/register_chain.move new file mode 100644 index 0000000000..90af5c1fbe --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/governance/register_chain.move @@ -0,0 +1,297 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact registering a +/// foreign Token Bridge for a particular chain ID. +module token_bridge::register_chain { + use sui::table::{Self}; + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + + use token_bridge::state::{Self, State, LatestOnly}; + + /// Cannot register chain ID == 0. + const E_INVALID_EMITTER_CHAIN: u64 = 0; + /// Emitter already exists for a given chain ID. + const E_EMITTER_ALREADY_REGISTERED: u64 = 1; + + /// Specific governance payload ID (action) for registering foreign Token + /// Bridge contract address. + const ACTION_REGISTER_CHAIN: u8 = 1; + + struct GovernanceWitness has drop {} + + struct RegisterChain { + chain: u16, + contract_address: ExternalAddress, + } + + public fun authorize_governance( + token_bridge_state: &State + ): DecreeTicket { + governance_message::authorize_verify_global( + GovernanceWitness {}, + state::governance_chain(token_bridge_state), + state::governance_contract(token_bridge_state), + state::governance_module(), + ACTION_REGISTER_CHAIN + ) + } + + public fun register_chain( + token_bridge_state: &mut State, + receipt: DecreeReceipt + ): ( + u16, + ExternalAddress + ) { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + let payload = + governance_message::take_payload( + state::borrow_mut_consumed_vaas( + &latest_only, + token_bridge_state + ), + receipt + ); + + handle_register_chain(&latest_only, token_bridge_state, payload) + } + + fun handle_register_chain( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + governance_payload: vector + ): ( + u16, + ExternalAddress + ) { + // Deserialize the payload as amount to change the Wormhole fee. + let RegisterChain { + chain, + contract_address + } = deserialize(governance_payload); + + register_new_emitter( + latest_only, + token_bridge_state, + chain, + contract_address + ); + + (chain, contract_address) + } + + fun deserialize(payload: vector): RegisterChain { + let cur = cursor::new(payload); + + // This amount cannot be greater than max u64. + let chain = bytes::take_u16_be(&mut cur); + let contract_address = external_address::take_bytes(&mut cur); + + cursor::destroy_empty(cur); + + RegisterChain { chain, contract_address} + } + + /// Add a new Token Bridge emitter to the registry. This method will abort + /// if an emitter is already registered for a particular chain ID. + /// + /// See `register_chain` module for more info. + fun register_new_emitter( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + chain: u16, + contract_address: ExternalAddress + ) { + assert!(chain != 0, E_INVALID_EMITTER_CHAIN); + + let registry = + state::borrow_mut_emitter_registry(latest_only, token_bridge_state); + assert!( + !table::contains(registry, chain), + E_EMITTER_ALREADY_REGISTERED + ); + table::add(registry, chain, contract_address); + } + + #[test_only] + public fun register_new_emitter_test_only( + token_bridge_state: &mut State, + chain: u16, + contract_address: ExternalAddress + ) { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + register_new_emitter( + &latest_only, + token_bridge_state, + chain, + contract_address + ); + } + + #[test_only] + public fun action(): u8 { + ACTION_REGISTER_CHAIN + } +} + +#[test_only] +module token_bridge::register_chain_tests { + use sui::table::{Self}; + use sui::test_scenario::{Self}; + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self}; + use wormhole::governance_message::{Self}; + use wormhole::wormhole_scenario::{ + parse_and_verify_vaa, + verify_governance_vaa + }; + + use token_bridge::register_chain::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + person, + return_state, + set_up_wormhole_and_token_bridge, + take_state + }; + + const VAA_REGISTER_CHAIN_1: vector = + x"01000000000100dd8cf046ad6dd17b2b5130d236b3545350899ac33b5c9e93e4d8c3e0da718a351c3f76cb9ddb15a0f0d7db7b1dded2b5e79c2f6e76dde6d8ed4bcb9cb461eb480100bc614e0000000000010000000000000000000000000000000000000000000000000000000000000004000000000000000101000000000000000000000000000000000000000000546f6b656e4272696467650100000002000000000000000000000000deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + const VAA_REGISTER_SAME_CHAIN: vector = + x"01000000000100847ca782db7616135de4a835ed5b12ba7946bbd39f70ecd9912ec55bdc9cb6c6215c98d6ad5c8d7253c2bb0fb0f8df0dc6591408c366cf0c09e58abcfb8c0abe0000bc614e0000000000010000000000000000000000000000000000000000000000000000000000000004000000000000000101000000000000000000000000000000000000000000546f6b656e427269646765010000000200000000000000000000000000000000000000000000000000000000deafbeef"; + + #[test] + fun test_register_chain() { + // Testing this method. + use token_bridge::register_chain::{register_chain}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + // Check that the emitter is not registered. + let expected_chain = 2; + { + let registry = state::borrow_emitter_registry(&token_bridge_state); + assert!(!table::contains(registry, expected_chain), 0); + }; + + let verified_vaa = parse_and_verify_vaa(scenario, VAA_REGISTER_CHAIN_1); + let ticket = register_chain::authorize_governance(&token_bridge_state); + let receipt = + verify_governance_vaa(scenario, verified_vaa, ticket); + let ( + chain, + contract_address + ) = register_chain(&mut token_bridge_state, receipt); + assert!(chain == expected_chain, 0); + + let expected_contract = + external_address::from_address( + @0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef + ); + assert!(contract_address == expected_contract, 0); + { + let registry = state::borrow_emitter_registry(&token_bridge_state); + assert!(*table::borrow(registry, expected_chain) == expected_contract, 0); + }; + + // Clean up. + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = register_chain::E_EMITTER_ALREADY_REGISTERED)] + fun test_cannot_register_chain_already_registered() { + // Testing this method. + use token_bridge::register_chain::{register_chain}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole and Token Bridge. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, VAA_REGISTER_CHAIN_1); + let ticket = register_chain::authorize_governance(&token_bridge_state); + let receipt = + verify_governance_vaa(scenario, verified_vaa, ticket); + let ( + chain, + _ + ) = register_chain(&mut token_bridge_state, receipt); + + // Check registry. + let expected_contract = + *table::borrow( + state::borrow_emitter_registry(&token_bridge_state), + chain + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let verified_vaa = + parse_and_verify_vaa(scenario, VAA_REGISTER_SAME_CHAIN); + let payload = + governance_message::take_decree( + wormhole::vaa::payload(&verified_vaa) + ); + let cur = cursor::new(payload); + + // Show this payload is attempting to register the same chain ID. + let another_chain = bytes::take_u16_be(&mut cur); + assert!(chain == another_chain, 0); + + let another_contract = external_address::take_bytes(&mut cur); + assert!(another_contract != expected_contract, 0); + + // No more payload to read. + cursor::destroy_empty(cur); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let ticket = register_chain::authorize_governance(&token_bridge_state); + let receipt = + verify_governance_vaa(scenario, verified_vaa, ticket); + + // You shall not pass! + register_chain(&mut token_bridge_state, receipt); + + abort 42 + } +} + + + + diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/governance/upgrade_contract.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/governance/upgrade_contract.move new file mode 100644 index 0000000000..e03729b021 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/governance/upgrade_contract.move @@ -0,0 +1,125 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact upgrading the +/// Token Bridge contract to a new build. The procedure to upgrade this contract +/// requires a Programmable Transaction, which includes the following procedure: +/// 1. Load new build. +/// 2. Authorize upgrade. +/// 3. Upgrade. +/// 4. Commit upgrade. +module token_bridge::upgrade_contract { + use sui::object::{ID}; + use sui::package::{UpgradeReceipt, UpgradeTicket}; + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::cursor::{Self}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + + use token_bridge::state::{Self, State}; + + friend token_bridge::migrate; + + /// Digest is all zeros. + const E_DIGEST_ZERO_BYTES: u64 = 0; + + /// Specific governance payload ID (action) to complete upgrading the + /// contract. + const ACTION_UPGRADE_CONTRACT: u8 = 2; + + struct GovernanceWitness has drop {} + + // Event reflecting package upgrade. + struct ContractUpgraded has drop, copy { + old_contract: ID, + new_contract: ID + } + + struct UpgradeContract { + digest: Bytes32 + } + + public fun authorize_governance( + token_bridge_state: &State + ): DecreeTicket { + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(token_bridge_state), + state::governance_contract(token_bridge_state), + state::governance_module(), + ACTION_UPGRADE_CONTRACT + ) + } + + /// Redeem governance VAA to issue an `UpgradeTicket` for the upgrade given + /// a contract upgrade VAA. This governance message is only relevant for Sui + /// because a contract upgrade is only relevant to one particular network + /// (in this case Sui), whose build digest is encoded in this message. + public fun authorize_upgrade( + token_bridge_state: &mut State, + receipt: DecreeReceipt + ): UpgradeTicket { + // current package checking when consuming VAA hashes. This is because + // upgrades are protected by the Sui VM, enforcing the latest package + // is the one performing the upgrade. + let consumed = + state::borrow_mut_consumed_vaas_unchecked(token_bridge_state); + + // And consume. + let payload = governance_message::take_payload(consumed, receipt); + + // Proceed with processing new implementation version. + handle_upgrade_contract(token_bridge_state, payload) + } + + /// Finalize the upgrade that ran to produce the given `receipt`. This + /// method invokes `state::commit_upgrade` which interacts with + /// `sui::package`. + public fun commit_upgrade( + self: &mut State, + receipt: UpgradeReceipt, + ) { + let (old_contract, new_contract) = state::commit_upgrade(self, receipt); + + // Emit an event reflecting package ID change. + sui::event::emit(ContractUpgraded { old_contract, new_contract }); + } + + /// Privileged method only to be used by this module and `migrate` module. + /// + /// During migration, we make sure that the digest equals what we expect by + /// passing in the same VAA used to upgrade the package. + public(friend) fun take_digest(governance_payload: vector): Bytes32 { + // Deserialize the payload as the build digest. + let UpgradeContract { digest } = deserialize(governance_payload); + + digest + } + + fun handle_upgrade_contract( + wormhole_state: &mut State, + payload: vector + ): UpgradeTicket { + state::authorize_upgrade(wormhole_state, take_digest(payload)) + } + + fun deserialize(payload: vector): UpgradeContract { + let cur = cursor::new(payload); + + // This amount cannot be greater than max u64. + let digest = bytes32::take_bytes(&mut cur); + assert!(bytes32::is_nonzero(&digest), E_DIGEST_ZERO_BYTES); + + cursor::destroy_empty(cur); + + UpgradeContract { digest } + } + + #[test_only] + public fun action(): u8 { + ACTION_UPGRADE_CONTRACT + } +} + +#[test_only] +module token_bridge::upgrade_contract_tests { + // TODO +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/messages/asset_meta.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/messages/asset_meta.move new file mode 100644 index 0000000000..30f03f2cde --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/messages/asset_meta.move @@ -0,0 +1,251 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements serialization and deserialization for asset metadata, +/// which is a specific Wormhole message payload for Token Bridge. +module token_bridge::asset_meta { + use std::string::{Self, String}; + use std::vector::{Self}; + use sui::coin::{Self, CoinMetadata}; + use wormhole::bytes::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + use wormhole::cursor::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::native_asset::{Self}; + + friend token_bridge::attest_token; + friend token_bridge::create_wrapped; + friend token_bridge::wrapped_asset; + + /// Message payload is not `AssetMeta`. + const E_INVALID_PAYLOAD: u64 = 0; + + /// Message identifier. + const PAYLOAD_ID: u8 = 2; + + /// Container that warehouses asset metadata information. This struct is + /// used only by `attest_token` and `create_wrapped` modules. + struct AssetMeta { + /// Address of the token. + token_address: ExternalAddress, + /// Chain ID of the token. + token_chain: u16, + /// Number of decimals of the token. + native_decimals: u8, + /// Symbol of the token (UTF-8). + /// TODO(csongor): maybe turn these into String32s? + symbol: String, + /// Name of the token (UTF-8). + name: String, + } + + + public(friend) fun from_metadata(metadata: &CoinMetadata): AssetMeta { + AssetMeta { + token_address: native_asset::canonical_address(metadata), + token_chain: chain_id(), + native_decimals: coin::get_decimals(metadata), + symbol: string::from_ascii(coin::get_symbol(metadata)), + name: coin::get_name(metadata) + } + } + + #[test_only] + public fun from_metadata_test_only(metadata: &CoinMetadata): AssetMeta { + from_metadata(metadata) + } + + public(friend) fun unpack( + meta: AssetMeta + ): ( + ExternalAddress, + u16, + u8, + String, + String + ) { + let AssetMeta { + token_address, + token_chain, + native_decimals, + symbol, + name + } = meta; + + ( + token_address, + token_chain, + native_decimals, + symbol, + name + ) + } + + + #[test_only] + public fun unpack_test_only( + meta: AssetMeta + ): ( + ExternalAddress, + u16, + u8, + String, + String + ) { + unpack(meta) + } + + public fun token_chain(self: &AssetMeta): u16 { + self.token_chain + } + + public fun token_address(self: &AssetMeta): ExternalAddress { + self.token_address + } + + public(friend) fun serialize(meta: AssetMeta): vector { + let ( + token_address, + token_chain, + native_decimals, + symbol, + name + ) = unpack(meta); + + let buf = vector::empty(); + bytes::push_u8(&mut buf, PAYLOAD_ID); + vector::append(&mut buf, external_address::to_bytes(token_address)); + bytes::push_u16_be(&mut buf, token_chain); + bytes::push_u8(&mut buf, native_decimals); + vector::append( + &mut buf, + bytes32::to_bytes(bytes32::from_utf8(symbol)) + ); + vector::append( + &mut buf, + bytes32::to_bytes(bytes32::from_utf8(name)) + ); + + buf + } + + #[test_only] + public fun serialize_test_only(meta: AssetMeta): vector { + serialize(meta) + } + + public(friend) fun deserialize(buf: vector): AssetMeta { + let cur = cursor::new(buf); + assert!(bytes::take_u8(&mut cur) == PAYLOAD_ID, E_INVALID_PAYLOAD); + let token_address = external_address::take_bytes(&mut cur); + let token_chain = bytes::take_u16_be(&mut cur); + let native_decimals = bytes::take_u8(&mut cur); + let symbol = bytes32::to_utf8(bytes32::take_bytes(&mut cur)); + let name = bytes32::to_utf8(bytes32::take_bytes(&mut cur)); + cursor::destroy_empty(cur); + + AssetMeta { + token_address, + token_chain, + native_decimals, + symbol, + name + } + } + + #[test_only] + public fun deserialize_test_only(buf: vector): AssetMeta { + deserialize(buf) + } + + #[test_only] + public fun new( + token_address: ExternalAddress, + token_chain: u16, + native_decimals: u8, + symbol: String, + name: String, + ): AssetMeta { + AssetMeta { + token_address, + token_chain, + native_decimals, + symbol, + name + } + } + + #[test_only] + public fun native_decimals(self: &AssetMeta): u8 { + self.native_decimals + } + + #[test_only] + public fun symbol(self: &AssetMeta): String { + self.symbol + } + + #[test_only] + public fun name(self: &AssetMeta): String { + self.name + } + + #[test_only] + public fun destroy(token_meta: AssetMeta) { + unpack(token_meta); + } + + #[test_only] + public fun payload_id(): u8 { + PAYLOAD_ID + } +} + +#[test_only] +module token_bridge::asset_meta_tests { + use std::string::{Self}; + use wormhole::external_address::{Self}; + use wormhole::vaa::{Self}; + + use token_bridge::asset_meta::{Self}; + + #[test] + fun test_serialize_deserialize() { + let token_address = external_address::from_address(@0x1122); + let symbol = string::utf8(b"a creative symbol"); + let name = string::utf8(b"a creative name"); + let asset_meta = asset_meta::new( + token_address, //token address + 3, // token chain + 4, //native decimals + symbol, // symbol + name, // name + ); + // Serialize and deserialize TransferWithPayload object. + let se = asset_meta::serialize_test_only(asset_meta); + let de = asset_meta::deserialize_test_only(se); + + // Test that the object fields are unchanged. + assert!(asset_meta::token_chain(&de) == 3, 0); + assert!(asset_meta::token_address(&de) == token_address, 0); + assert!(asset_meta::native_decimals(&de) == 4, 0); + assert!(asset_meta::symbol(&de) == symbol, 0); + assert!(asset_meta::name(&de) == name, 0); + + // Clean up. + asset_meta::destroy(de); + } + + #[test] + fun test_create_wrapped_12() { + use token_bridge::dummy_message::{encoded_asset_meta_vaa_foreign_12}; + + let payload = + vaa::peel_payload_from_vaa(&encoded_asset_meta_vaa_foreign_12()); + + let token_meta = asset_meta::deserialize_test_only(payload); + let serialized = asset_meta::serialize_test_only(token_meta); + assert!(payload == serialized, 0); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/messages/transfer.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/messages/transfer.move new file mode 100644 index 0000000000..190afad9dc --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/messages/transfer.move @@ -0,0 +1,311 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements serialization and deserialization for token transfer +/// with an optional relayer fee. This message is a specific Wormhole message +/// payload for Token Bridge. +/// +/// When this transfer is redeemed, the relayer fee will be subtracted from the +/// transfer amount. If the transaction sender is the same address of the +/// recipient, the recipient will collect the full amount. +/// +/// See `transfer_tokens` and `complete_transfer` modules for more details. +module token_bridge::transfer { + use std::vector::{Self}; + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + + use token_bridge::normalized_amount::{Self, NormalizedAmount}; + + friend token_bridge::complete_transfer; + friend token_bridge::transfer_tokens; + + /// Message payload is not `Transfer`. + const E_INVALID_PAYLOAD: u64 = 0; + + /// Message identifier. + const PAYLOAD_ID: u8 = 1; + + /// Container that warehouses transfer information. This struct is used only + /// by `transfer_tokens` and `complete_transfer` modules. + struct Transfer { + // Amount being transferred. + amount: NormalizedAmount, + // Address of the token. Left-zero-padded if shorter than 32 bytes. + token_address: ExternalAddress, + // Chain ID of the token. + token_chain: u16, + // Address of the recipient. Left-zero-padded if shorter than 32 bytes. + recipient: ExternalAddress, + // Chain ID of the recipient. + recipient_chain: u16, + // Amount of tokens that the user is willing to pay as relayer fee. + // Must be <= amount. + relayer_fee: NormalizedAmount, + } + + /// Create new `Transfer`. + public(friend) fun new( + amount: NormalizedAmount, + token_address: ExternalAddress, + token_chain: u16, + recipient: ExternalAddress, + recipient_chain: u16, + relayer_fee: NormalizedAmount, + ): Transfer { + Transfer { + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee, + } + } + + #[test_only] + public fun new_test_only( + amount: NormalizedAmount, + token_address: ExternalAddress, + token_chain: u16, + recipient: ExternalAddress, + recipient_chain: u16, + relayer_fee: NormalizedAmount, + ): Transfer { + new( + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee + ) + } + + /// Decompose `Transfer` into its members. + public(friend) fun unpack( + transfer: Transfer + ): ( + NormalizedAmount, + ExternalAddress, + u16, + ExternalAddress, + u16, + NormalizedAmount + ) { + let Transfer { + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee, + } = transfer; + + ( + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee + ) + } + + #[test_only] + public fun unpack_test_only( + transfer: Transfer + ): ( + NormalizedAmount, + ExternalAddress, + u16, + ExternalAddress, + u16, + NormalizedAmount + ) { + unpack(transfer) + } + + /// Decode Wormhole message payload as `Transfer`. + public(friend) fun deserialize(buf: vector): Transfer { + let cur = cursor::new(buf); + assert!(bytes::take_u8(&mut cur) == PAYLOAD_ID, E_INVALID_PAYLOAD); + + let amount = normalized_amount::take_bytes(&mut cur); + let token_address = external_address::take_bytes(&mut cur); + let token_chain = bytes::take_u16_be(&mut cur); + let recipient = external_address::take_bytes(&mut cur); + let recipient_chain = bytes::take_u16_be(&mut cur); + let relayer_fee = normalized_amount::take_bytes(&mut cur); + cursor::destroy_empty(cur); + + Transfer { + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee, + } + } + + #[test_only] + public fun deserialize_test_only(buf: vector): Transfer { + deserialize(buf) + } + + /// Encode `Transfer` for Wormhole message payload. + public(friend) fun serialize(transfer: Transfer): vector { + let ( + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee, + ) = unpack(transfer); + + let buf = vector::empty(); + bytes::push_u8(&mut buf, PAYLOAD_ID); + vector::append(&mut buf, normalized_amount::to_bytes(amount)); + vector::append(&mut buf, external_address::to_bytes(token_address)); + bytes::push_u16_be(&mut buf, token_chain); + vector::append(&mut buf, external_address::to_bytes(recipient)); + bytes::push_u16_be(&mut buf, recipient_chain); + vector::append(&mut buf, normalized_amount::to_bytes(relayer_fee)); + + buf + } + + #[test_only] + public fun serialize_test_only(transfer: Transfer): vector { + serialize(transfer) + } + + #[test_only] + public fun amount(self: &Transfer): NormalizedAmount { + self.amount + } + + #[test_only] + public fun raw_amount(self: &Transfer, decimals: u8): u64 { + normalized_amount::to_raw(self.amount, decimals) + } + + #[test_only] + public fun token_address(self: &Transfer): ExternalAddress { + self.token_address + } + + #[test_only] + public fun token_chain(self: &Transfer): u16 { + self.token_chain + } + + #[test_only] + public fun recipient(self: &Transfer): ExternalAddress { + self.recipient + } + + #[test_only] + public fun recipient_as_address(self: &Transfer): address { + external_address::to_address(self.recipient) + } + + #[test_only] + public fun recipient_chain(self: &Transfer): u16 { + self.recipient_chain + } + + #[test_only] + public fun relayer_fee(self: &Transfer): NormalizedAmount { + self.relayer_fee + } + + #[test_only] + public fun raw_relayer_fee(self: &Transfer, decimals: u8): u64 { + normalized_amount::to_raw(self.relayer_fee, decimals) + } + + #[test_only] + public fun destroy(transfer: Transfer) { + unpack(transfer); + } + + #[test_only] + public fun payload_id(): u8 { + PAYLOAD_ID + } +} + +#[test_only] +module token_bridge::transfer_tests { + use std::vector::{Self}; + use wormhole::external_address::{Self}; + + use token_bridge::dummy_message::{Self}; + use token_bridge::transfer::{Self}; + use token_bridge::normalized_amount::{Self}; + + #[test] + fun test_serialize_deserialize() { + let decimals = 8; + let expected_amount = normalized_amount::from_raw(234567890, decimals); + let expected_token_address = external_address::from_address(@0xbeef); + let expected_token_chain = 1; + let expected_recipient = external_address::from_address(@0xcafe); + let expected_recipient_chain = 7; + let expected_relayer_fee = + normalized_amount::from_raw(123456789, decimals); + + let serialized = + transfer::serialize_test_only( + transfer::new_test_only( + expected_amount, + expected_token_address, + expected_token_chain, + expected_recipient, + expected_recipient_chain, + expected_relayer_fee, + ) + ); + assert!(serialized == dummy_message::encoded_transfer(), 0); + + let ( + amount, + token_address, + token_chain, + recipient, + recipient_chain, + relayer_fee + ) = transfer::unpack_test_only( + transfer::deserialize_test_only(serialized) + ); + assert!(amount == expected_amount, 0); + assert!(token_address == expected_token_address, 0); + assert!(token_chain == expected_token_chain, 0); + assert!(recipient == expected_recipient, 0); + assert!(recipient_chain == expected_recipient_chain, 0); + assert!(relayer_fee == expected_relayer_fee, 0); + } + + #[test] + #[expected_failure(abort_code = transfer::E_INVALID_PAYLOAD)] + fun test_cannot_deserialize_invalid_payload() { + let invalid_payload = dummy_message::encoded_transfer_with_payload(); + + // Show that the first byte is not the expected payload ID. + assert!( + *vector::borrow(&invalid_payload, 0) != transfer::payload_id(), + 0 + ); + + // You shall not pass! + let parsed = transfer::deserialize_test_only(invalid_payload); + + // Clean up. + transfer::destroy(parsed); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/messages/transfer_with_payload.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/messages/transfer_with_payload.move new file mode 100644 index 0000000000..3180616872 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/messages/transfer_with_payload.move @@ -0,0 +1,352 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements serialization and deserialization for token transfer +/// with an arbitrary payload. This message is a specific Wormhole message +/// payload for Token Bridge. +/// +/// In order to redeem these types of transfers, one must have an `EmitterCap` +/// and the specified `redeemer` must agree with this capability. +/// +/// See `transfer_tokens_with_payload` and `complete_transfer_with_payload` +/// modules for more details. +module token_bridge::transfer_with_payload { + use std::vector::{Self}; + use sui::object::{Self, ID}; + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + + use token_bridge::normalized_amount::{Self, NormalizedAmount}; + + friend token_bridge::transfer_tokens_with_payload; + + /// Message payload is not `TransferWithPayload`. + const E_INVALID_PAYLOAD: u64 = 0; + + /// Message identifier. + const PAYLOAD_ID: u8 = 3; + + /// Container that warehouses transfer information, including arbitrary + /// payload. + /// + /// NOTE: This struct has `drop` because we do not want to require an + /// integrator receiving transfer information to have to manually destroy. + struct TransferWithPayload has drop { + // Transfer amount. + amount: NormalizedAmount, + // Address of the token. Left-zero-padded if shorter than 32 bytes. + token_address: ExternalAddress, + // Chain ID of the token. + token_chain: u16, + // A.K.A. 32-byte representation of `EmitterCap`. + redeemer: ExternalAddress, + // Chain ID of the redeemer. + redeemer_chain: u16, + // Address of the message sender. + sender: ExternalAddress, + // An arbitrary payload. + payload: vector, + } + + /// Create new `TransferWithPayload` using a Token Bridge integrator's + /// emitter cap ID as the sender. + public(friend) fun new( + sender: ID, + amount: NormalizedAmount, + token_address: ExternalAddress, + token_chain: u16, + redeemer: ExternalAddress, + redeemer_chain: u16, + payload: vector + ): TransferWithPayload { + TransferWithPayload { + amount, + token_address, + token_chain, + redeemer, + redeemer_chain, + sender: external_address::from_id(sender), + payload + } + } + + #[test_only] + public fun new_test_only( + sender: ID, + amount: NormalizedAmount, + token_address: ExternalAddress, + token_chain: u16, + redeemer: ExternalAddress, + redeemer_chain: u16, + payload: vector + ): TransferWithPayload { + new( + sender, + amount, + token_address, + token_chain, + redeemer, + redeemer_chain, + payload + ) + } + + /// Destroy `TransferWithPayload` and take only its payload. + public fun take_payload(transfer: TransferWithPayload): vector { + let TransferWithPayload { + amount: _, + token_address: _, + token_chain: _, + redeemer: _, + redeemer_chain: _, + sender: _, + payload + } = transfer; + + payload + } + + /// Retrieve normalized amount of token transfer. + public fun amount(self: &TransferWithPayload): NormalizedAmount { + self.amount + } + + // Retrieve token's canonical address. + public fun token_address(self: &TransferWithPayload): ExternalAddress { + self.token_address + } + + /// Retrieve token's canonical chain ID. + public fun token_chain(self: &TransferWithPayload): u16 { + self.token_chain + } + + /// Retrieve redeemer. + public fun redeemer(self: &TransferWithPayload): ExternalAddress { + self.redeemer + } + + // Retrieve redeemer as `ID`. + public fun redeemer_id(self: &TransferWithPayload): ID { + object::id_from_bytes(external_address::to_bytes(self.redeemer)) + } + + /// Retrieve target chain for redeemer. + public fun redeemer_chain(self: &TransferWithPayload): u16 { + self.redeemer_chain + } + + /// Retrieve transfer sender. + public fun sender(self: &TransferWithPayload): ExternalAddress { + self.sender + } + + /// Retrieve arbitrary payload. + public fun payload(self: &TransferWithPayload): vector { + self.payload + } + + /// Decode Wormhole message payload as `TransferWithPayload`. + public fun deserialize(transfer: vector): TransferWithPayload { + let cur = cursor::new(transfer); + assert!(bytes::take_u8(&mut cur) == PAYLOAD_ID, E_INVALID_PAYLOAD); + + let amount = normalized_amount::take_bytes(&mut cur); + let token_address = external_address::take_bytes(&mut cur); + let token_chain = bytes::take_u16_be(&mut cur); + let redeemer = external_address::take_bytes(&mut cur); + let redeemer_chain = bytes::take_u16_be(&mut cur); + let sender = external_address::take_bytes(&mut cur); + + TransferWithPayload { + amount, + token_address, + token_chain, + redeemer, + redeemer_chain, + sender, + payload: cursor::take_rest(cur) + } + } + + /// Encode `TransferWithPayload` for Wormhole message payload. + public fun serialize(transfer: TransferWithPayload): vector { + let TransferWithPayload { + amount, + token_address, + token_chain, + redeemer, + redeemer_chain, + sender, + payload + } = transfer; + + let buf = vector::empty(); + bytes::push_u8(&mut buf, PAYLOAD_ID); + bytes::push_u256_be(&mut buf, normalized_amount::to_u256(amount)); + vector::append(&mut buf, external_address::to_bytes(token_address)); + bytes::push_u16_be(&mut buf, token_chain); + vector::append(&mut buf, external_address::to_bytes(redeemer)); + bytes::push_u16_be(&mut buf, redeemer_chain); + vector::append(&mut buf, external_address::to_bytes(sender)); + vector::append(&mut buf, payload); + + buf + } + + #[test_only] + public fun destroy(transfer: TransferWithPayload) { + take_payload(transfer); + } + + #[test_only] + public fun payload_id(): u8 { + PAYLOAD_ID + } +} + +#[test_only] +module token_bridge::transfer_with_payload_tests { + use std::vector::{Self}; + use sui::object::{Self}; + use wormhole::emitter::{Self}; + use wormhole::external_address::{Self}; + + use token_bridge::dummy_message::{Self}; + use token_bridge::normalized_amount::{Self}; + use token_bridge::transfer_with_payload::{Self}; + + #[test] + fun test_serialize() { + let emitter_cap = emitter::dummy(); + let amount = normalized_amount::from_raw(234567890, 8); + let token_address = external_address::from_address(@0xbeef); + let token_chain = 1; + let redeemer = external_address::from_address(@0xcafe); + let redeemer_chain = 7; + let payload = b"All your base are belong to us."; + + let new_transfer = + transfer_with_payload::new_test_only( + object::id(&emitter_cap), + amount, + token_address, + token_chain, + redeemer, + redeemer_chain, + payload + ); + + // Verify getters. + assert!( + transfer_with_payload::amount(&new_transfer) == amount, + 0 + ); + assert!( + transfer_with_payload::token_address(&new_transfer) == token_address, + 0 + ); + assert!( + transfer_with_payload::token_chain(&new_transfer) == token_chain, + 0 + ); + assert!( + transfer_with_payload::redeemer(&new_transfer) == redeemer, + 0 + ); + assert!( + transfer_with_payload::redeemer_chain(&new_transfer) == redeemer_chain, + 0 + ); + let expected_sender = + external_address::from_id(object::id(&emitter_cap)); + assert!( + transfer_with_payload::sender(&new_transfer) == expected_sender, + 0 + ); + assert!( + transfer_with_payload::payload(&new_transfer) == payload, + 0 + ); + + let serialized = transfer_with_payload::serialize(new_transfer); + let expected_serialized = + dummy_message::encoded_transfer_with_payload(); + assert!(serialized == expected_serialized, 0); + + // Clean up. + emitter::destroy_test_only(emitter_cap); + } + + #[test] + fun test_deserialize() { + let expected_amount = normalized_amount::from_raw(234567890, 8); + let expected_token_address = external_address::from_address(@0xbeef); + let expected_token_chain = 1; + let expected_recipient = external_address::from_address(@0xcafe); + let expected_recipient_chain = 7; + let expected_sender = + external_address::from_address( + @0x381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f409 + ); + let expected_payload = b"All your base are belong to us."; + + let parsed = + transfer_with_payload::deserialize( + dummy_message::encoded_transfer_with_payload() + ); + + // Verify getters. + assert!( + transfer_with_payload::amount(&parsed) == expected_amount, + 0 + ); + assert!( + transfer_with_payload::token_address(&parsed) == expected_token_address, + 0 + ); + assert!( + transfer_with_payload::token_chain(&parsed) == expected_token_chain, + 0 + ); + assert!( + transfer_with_payload::redeemer(&parsed) == expected_recipient, + 0 + ); + assert!( + transfer_with_payload::redeemer_chain(&parsed) == expected_recipient_chain, + 0 + ); + assert!( + transfer_with_payload::sender(&parsed) == expected_sender, + 0 + ); + assert!( + transfer_with_payload::payload(&parsed) == expected_payload, + 0 + ); + + let payload = transfer_with_payload::take_payload(parsed); + assert!(payload == expected_payload, 0); + } + + #[test] + #[expected_failure(abort_code = transfer_with_payload::E_INVALID_PAYLOAD)] + fun test_cannot_deserialize_invalid_payload() { + let invalid_payload = token_bridge::dummy_message::encoded_transfer(); + + // Show that the first byte is not the expected payload ID. + assert!( + *vector::borrow(&invalid_payload, 0) != transfer_with_payload::payload_id(), + 0 + ); + + // You shall not pass! + let parsed = transfer_with_payload::deserialize(invalid_payload); + + // Clean up. + transfer_with_payload::destroy(parsed); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/migrate.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/migrate.move new file mode 100644 index 0000000000..e3559de48a --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/migrate.move @@ -0,0 +1,216 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a public method intended to be called after an +/// upgrade has been committed. The purpose is to add one-off migration logic +/// that would alter Token Bridge `State`. +/// +/// Included in migration is the ability to ensure that breaking changes for +/// any of Token Bridge's methods by enforcing the current build version as +/// their required minimum version. +module token_bridge::migrate { + use sui::object::{ID}; + use wormhole::governance_message::{Self, DecreeReceipt}; + + use token_bridge::state::{Self, State}; + use token_bridge::upgrade_contract::{Self}; + + /// Event reflecting when `migrate` is successfully executed. + struct MigrateComplete has drop, copy { + package: ID + } + + /// Execute migration logic. See `token_bridge::migrate` description for + /// more info. + public fun migrate( + token_bridge_state: &mut State, + receipt: DecreeReceipt + ) { + state::migrate__v__0_2_0(token_bridge_state); + + // Perform standard migrate. + handle_migrate(token_bridge_state, receipt); + + //////////////////////////////////////////////////////////////////////// + // + // NOTE: Put any one-off migration logic here. + // + // Most upgrades likely won't need to do anything, in which case the + // rest of this function's body may be empty. Make sure to delete it + // after the migration has gone through successfully. + // + // WARNING: The migration does *not* proceed atomically with the + // upgrade (as they are done in separate transactions). + // If the nature of this migration absolutely requires the migration to + // happen before certain other functionality is available, then guard + // that functionality with the `assert!` from above. + // + //////////////////////////////////////////////////////////////////////// + + //////////////////////////////////////////////////////////////////////// + } + + fun handle_migrate( + token_bridge_state: &mut State, + receipt: DecreeReceipt + ) { + // Update the version first. + // + // See `version_control` module for hard-coded configuration. + state::migrate_version(token_bridge_state); + + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // Check if build digest is the current one. + let digest = + upgrade_contract::take_digest( + governance_message::payload(&receipt) + ); + state::assert_authorized_digest( + &latest_only, + token_bridge_state, + digest + ); + governance_message::destroy(receipt); + + // Finally emit an event reflecting a successful migrate. + let package = state::current_package(&latest_only, token_bridge_state); + sui::event::emit(MigrateComplete { package }); + } + + #[test_only] + public fun set_up_migrate(token_bridge_state: &mut State) { + state::reverse_migrate__v__dummy(token_bridge_state); + } +} + +#[test_only] +module token_bridge::migrate_tests { + use sui::test_scenario::{Self}; + use wormhole::wormhole_scenario::{ + parse_and_verify_vaa, + verify_governance_vaa + }; + + use token_bridge::state::{Self}; + use token_bridge::upgrade_contract::{Self}; + use token_bridge::token_bridge_scenario::{ + person, + return_state, + set_up_wormhole_and_token_bridge, + take_state, + upgrade_token_bridge + }; + + const UPGRADE_VAA: vector = + x"010000000001005b18d7710c442414435162dc2b46a421c3018a7ff03290eff112a828b7927e4a6a624174cb8385210f4684ac2dbde6e01e4046218f7f245af53e85c97a48e21a0100bc614e0000000000010000000000000000000000000000000000000000000000000000000000000004000000000000000101000000000000000000000000000000000000000000546f6b656e42726964676502001500000000000000000000000000000000000000000000006e6577206275696c64"; + + #[test] + fun test_migrate() { + use token_bridge::migrate::{migrate}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole. + let wormhole_message_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + // Upgrade (digest is just b"new build") for testing purposes. + upgrade_token_bridge(scenario); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + // Set up migrate (which prepares this package to be the same state as + // a previous release). + token_bridge::migrate::set_up_migrate(&mut token_bridge_state); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + let verified_vaa = parse_and_verify_vaa(scenario, UPGRADE_VAA); + let ticket = + upgrade_contract::authorize_governance(&token_bridge_state); + let receipt = + verify_governance_vaa(scenario, verified_vaa, ticket); + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + migrate(&mut token_bridge_state, receipt); + + // Make sure we emitted an event. + let effects = test_scenario::next_tx(scenario, user); + assert!(test_scenario::num_user_events(&effects) == 1, 0); + + // Clean up. + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_INCORRECT_OLD_VERSION)] + /// ^ This expected error may change depending on the migration. In most + /// cases, this will abort with `wormhole::package_utils::E_INCORRECT_OLD_VERSION`. + fun test_cannot_migrate_again() { + use token_bridge::migrate::{migrate}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole. + let wormhole_message_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + // Upgrade (digest is just b"new build") for testing purposes. + upgrade_token_bridge(scenario); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let token_bridge_state = take_state(scenario); + + // Set up migrate (which prepares this package to be the same state as + // a previous release). + token_bridge::migrate::set_up_migrate(&mut token_bridge_state); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + let verified_vaa = parse_and_verify_vaa(scenario, UPGRADE_VAA); + let ticket = + upgrade_contract::authorize_governance(&token_bridge_state); + let receipt = + verify_governance_vaa(scenario, verified_vaa, ticket); + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + migrate(&mut token_bridge_state, receipt); + + // Make sure we emitted an event. + let effects = test_scenario::next_tx(scenario, user); + assert!(test_scenario::num_user_events(&effects) == 1, 0); + + let verified_vaa = parse_and_verify_vaa(scenario, UPGRADE_VAA); + let ticket = + upgrade_contract::authorize_governance(&token_bridge_state); + let receipt = + verify_governance_vaa(scenario, verified_vaa, ticket); + // You shall not pass! + migrate(&mut token_bridge_state, receipt); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/resources/native_asset.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/resources/native_asset.move new file mode 100644 index 0000000000..dba6b91960 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/resources/native_asset.move @@ -0,0 +1,220 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type that keeps track of info relating to +/// assets (coin types) native to Sui. Token Bridge takes custody of these +/// assets when someone invokes a token transfer outbound. Likewise, Token +/// Bridge releases some of its balance from its custody of when someone redeems +/// an inbound token transfer intended for Sui. +/// +/// See `token_registry` module for more details. +module token_bridge::native_asset { + use sui::balance::{Self, Balance}; + use sui::coin::{Self, CoinMetadata}; + use sui::object::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + use wormhole::state::{chain_id}; + + friend token_bridge::complete_transfer; + friend token_bridge::token_registry; + friend token_bridge::transfer_tokens; + + /// Container for storing canonical token address and custodied `Balance`. + struct NativeAsset has store { + custody: Balance, + token_address: ExternalAddress, + decimals: u8 + } + + /// Token Bridge identifies native assets using `CoinMetadata` object `ID`. + /// This method converts this `ID` to `ExternalAddress`. + public fun canonical_address( + metadata: &CoinMetadata + ): ExternalAddress { + external_address::from_id(object::id(metadata)) + } + + /// Create new `NativeAsset`. + /// + /// NOTE: The canonical token address is determined by the coin metadata's + /// object ID. + public(friend) fun new(metadata: &CoinMetadata): NativeAsset { + NativeAsset { + custody: balance::zero(), + token_address: canonical_address(metadata), + decimals: coin::get_decimals(metadata) + } + } + + #[test_only] + public fun new_test_only(metadata: &CoinMetadata): NativeAsset { + new(metadata) + } + + /// Retrieve canonical token address. + public fun token_address(self: &NativeAsset): ExternalAddress { + self.token_address + } + + /// Retrieve decimals, which originated from `CoinMetadata`. + public fun decimals(self: &NativeAsset): u8 { + self.decimals + } + + /// Retrieve custodied `Balance` value. + public fun custody(self: &NativeAsset): u64 { + balance::value(&self.custody) + } + + /// Retrieve canonical token chain ID (Sui's) and token address. + public fun canonical_info( + self: &NativeAsset + ): (u16, ExternalAddress) { + (chain_id(), self.token_address) + } + + /// Deposit a given `Balance`. `Balance` originates from an outbound token + /// transfer for a native asset. + /// + /// See `transfer_tokens` module for more info. + public(friend) fun deposit( + self: &mut NativeAsset, + deposited: Balance + ) { + balance::join(&mut self.custody, deposited); + } + + #[test_only] + public fun deposit_test_only( + self: &mut NativeAsset, + deposited: Balance + ) { + deposit(self, deposited) + } + + /// Withdraw a given amount from custody. This amount is determiend by an + /// inbound token transfer payload for a native asset. + /// + /// See `complete_transfer` module for more info. + public(friend) fun withdraw( + self: &mut NativeAsset, + amount: u64 + ): Balance { + balance::split(&mut self.custody, amount) + } + + #[test_only] + public fun withdraw_test_only( + self: &mut NativeAsset, + amount: u64 + ): Balance { + withdraw(self, amount) + } + + #[test_only] + public fun destroy(asset: NativeAsset) { + let NativeAsset { + custody, + token_address: _, + decimals: _ + } = asset; + balance::destroy_for_testing(custody); + } +} + +#[test_only] +module token_bridge::native_asset_tests { + use sui::balance::{Self}; + use sui::coin::{Self}; + use sui::object::{Self}; + use sui::test_scenario::{Self}; + use wormhole::external_address::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::native_asset::{Self}; + use token_bridge::token_bridge_scenario::{person}; + + #[test] + /// In this test, we exercise all the functionalities of a native asset + /// object, including new, deposit, withdraw, to_token_info, as well as + /// getting fields token_address, decimals, balance. + fun test_native_asset() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Publish coin. + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let coin_meta = coin_native_10::take_metadata(scenario); + + // Make new. + let asset = native_asset::new_test_only(&coin_meta); + + // Assert token address and decimals are correct. + let expected_token_address = + external_address::from_id(object::id(&coin_meta)); + assert!( + native_asset::token_address(&asset) == expected_token_address, + 0 + ); + assert!( + native_asset::decimals(&asset) == coin::get_decimals(&coin_meta), + 0 + ); + assert!(native_asset::custody(&asset) == 0, 0); + + // deposit some coins into the NativeAsset coin custody + let deposit_amount = 1000; + let (i, n) = (0, 8); + while (i < n) { + native_asset::deposit_test_only( + &mut asset, + balance::create_for_testing( + deposit_amount + ) + ); + i = i + 1; + }; + let total_deposited = n * deposit_amount; + assert!(native_asset::custody(&asset) == total_deposited, 0); + + let withdraw_amount = 690; + let total_withdrawn = balance::zero(); + let i = 0; + while (i < n) { + let withdrawn = native_asset::withdraw_test_only( + &mut asset, + withdraw_amount + ); + assert!(balance::value(&withdrawn) == withdraw_amount, 0); + balance::join(&mut total_withdrawn, withdrawn); + i = i + 1; + }; + + // convert to token info and assert convrsion is correct + let ( + token_chain, + token_address + ) = native_asset::canonical_info(&asset); + + assert!(token_chain == chain_id(), 0); + assert!(token_address == expected_token_address, 0); + + // check that updated balance is correct + let expected_remaining = total_deposited - n * withdraw_amount; + let remaining = native_asset::custody(&asset); + assert!(remaining == expected_remaining, 0); + + // Clean up. + coin_native_10::return_metadata(coin_meta); + balance::destroy_for_testing(total_withdrawn); + native_asset::destroy(asset); + + // Done. + test_scenario::end(my_scenario); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/resources/token_registry.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/resources/token_registry.move new file mode 100644 index 0000000000..f03f1d3383 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/resources/token_registry.move @@ -0,0 +1,784 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type that keeps track of both native and +/// wrapped assets via dynamic fields. These dynamic fields are keyed off using +/// coin types. This registry lives in `State`. +/// +/// See `state` module for more details. +module token_bridge::token_registry { + use std::ascii::{String}; + use std::type_name::{Self}; + use sui::coin::{TreasuryCap, CoinMetadata}; + use sui::dynamic_field::{Self}; + use sui::object::{Self, UID}; + use sui::package::{UpgradeCap}; + use sui::table::{Self, Table}; + use sui::tx_context::{TxContext}; + use wormhole::external_address::{Self, ExternalAddress}; + + use token_bridge::asset_meta::{Self, AssetMeta}; + use token_bridge::native_asset::{Self, NativeAsset}; + use token_bridge::wrapped_asset::{Self, WrappedAsset}; + + friend token_bridge::attest_token; + friend token_bridge::complete_transfer; + friend token_bridge::create_wrapped; + friend token_bridge::state; + friend token_bridge::transfer_tokens; + + /// Asset is not registered yet. + const E_UNREGISTERED: u64 = 0; + /// Cannot register wrapped asset with same canonical token info. + const E_ALREADY_WRAPPED: u64 = 1; + + /// This container is used to store native and wrapped assets of coin type + /// as dynamic fields under its `UID`. It also uses a mechanism to generate + /// arbitrary token addresses for native assets. + struct TokenRegistry has key, store { + id: UID, + num_wrapped: u64, + num_native: u64, + coin_types: Table + } + + /// Container to provide convenient checking of whether an asset is wrapped + /// or native. `VerifiedAsset` can only be created either by passing in a + /// resource with `CoinType` or by verifying input token info against the + /// canonical info that exists in `TokenRegistry`. + /// + /// NOTE: This container can be dropped after it was created. + struct VerifiedAsset has drop { + is_wrapped: bool, + chain: u16, + addr: ExternalAddress, + coin_decimals: u8 + } + + /// Wrapper of coin type to act as dynamic field key. + struct Key has copy, drop, store {} + + /// This struct is not used for anything within the contract. It exists + /// purely for someone with an RPC query to be able to fetch the type name + /// of coin type as a string via `TokenRegistry`. + struct CoinTypeKey has drop, copy, store { + chain: u16, + addr: vector + } + + /// Create new `TokenRegistry`. + /// + /// See `setup` module for more info. + public(friend) fun new(ctx: &mut TxContext): TokenRegistry { + TokenRegistry { + id: object::new(ctx), + num_wrapped: 0, + num_native: 0, + coin_types: table::new(ctx) + } + } + + #[test_only] + public fun new_test_only(ctx: &mut TxContext): TokenRegistry { + new(ctx) + } + + /// Determine whether a particular coin type is registered. + public fun has(self: &TokenRegistry): bool { + dynamic_field::exists_(&self.id, Key {}) + } + + public fun assert_has(self: &TokenRegistry) { + assert!(has(self), E_UNREGISTERED); + } + + public fun verified_asset( + self: &TokenRegistry + ): VerifiedAsset { + // We check specifically whether `CoinType` is associated with a dynamic + // field for `WrappedAsset`. This boolean will be used as the underlying + // value for `VerifiedAsset`. + let is_wrapped = + dynamic_field::exists_with_type, WrappedAsset>( + &self.id, + Key {} + ); + if (is_wrapped) { + let asset = borrow_wrapped(self); + let (chain, addr) = wrapped_asset::canonical_info(asset); + let coin_decimals = wrapped_asset::decimals(asset); + + VerifiedAsset { is_wrapped, chain, addr, coin_decimals } + } else { + let asset = borrow_native(self); + let (chain, addr) = native_asset::canonical_info(asset); + let coin_decimals = native_asset::decimals(asset); + + VerifiedAsset { is_wrapped, chain, addr, coin_decimals } + } + } + + /// Determine whether a given `CoinType` is a wrapped asset. + public fun is_wrapped(verified: &VerifiedAsset): bool { + verified.is_wrapped + } + + /// Retrieve canonical token chain ID from `VerifiedAsset`. + public fun token_chain( + verified: &VerifiedAsset + ): u16 { + verified.chain + } + + /// Retrieve canonical token address from `VerifiedAsset`. + public fun token_address( + verified: &VerifiedAsset + ): ExternalAddress { + verified.addr + } + + /// Retrieve decimals for a `VerifiedAsset`. + public fun coin_decimals( + verified: &VerifiedAsset + ): u8 { + verified.coin_decimals + } + + /// Add a new wrapped asset to the registry and return the canonical token + /// address. + /// + /// See `state` module for more info. + public(friend) fun add_new_wrapped( + self: &mut TokenRegistry, + token_meta: AssetMeta, + coin_meta: &mut CoinMetadata, + treasury_cap: TreasuryCap, + upgrade_cap: UpgradeCap + ): ExternalAddress { + // Grab canonical token info. + let token_chain = asset_meta::token_chain(&token_meta); + let token_addr = asset_meta::token_address(&token_meta); + + let coin_types = &mut self.coin_types; + let key = + CoinTypeKey { + chain: token_chain, + addr: external_address::to_bytes(token_addr) + }; + // We need to make sure that the canonical token info has not been + // created for another coin type. This can happen if asset metadata + // is attested again from a foreign chain and another coin type is + // published using its VAA. + assert!(!table::contains(coin_types, key), E_ALREADY_WRAPPED); + + // Now add the coin type. + table::add( + coin_types, + key, + type_name::into_string(type_name::get()) + ); + + // NOTE: We do not assert that the coin type has not already been + // registered using !has(self) because `wrapped_asset::new` + // consumes `TreasuryCap`. This `TreasuryCap` is only created once for a particuar + // coin type via `create_wrapped::prepare_registration`. Because the + // `TreasuryCap` is globally unique and can only be created once, there is no + // risk that `add_new_wrapped` can be called again on the same coin + // type. + let asset = + wrapped_asset::new( + token_meta, + coin_meta, + treasury_cap, + upgrade_cap + ); + dynamic_field::add(&mut self.id, Key {}, asset); + self.num_wrapped = self.num_wrapped + 1; + + token_addr + } + + #[test_only] + public fun add_new_wrapped_test_only( + self: &mut TokenRegistry, + token_meta: AssetMeta, + coin_meta: &mut CoinMetadata, + treasury_cap: TreasuryCap, + ctx: &mut TxContext + ): ExternalAddress { + add_new_wrapped( + self, + token_meta, + coin_meta, + treasury_cap, + sui::package::test_publish( + object::id_from_address(@token_bridge), + ctx + ) + ) + } + + /// Add a new native asset to the registry and return the canonical token + /// address. + /// + /// NOTE: This method does not verify if `CoinType` is already in the + /// registry because `attest_token` already takes care of this check. If + /// This method were to be called on an already-registered asset, this + /// will throw with an error from `sui::dynamic_field` reflectina duplicate + /// field. + /// + /// See `attest_token` module for more info. + public(friend) fun add_new_native( + self: &mut TokenRegistry, + metadata: &CoinMetadata, + ): ExternalAddress { + // Create new native asset. + let asset = native_asset::new(metadata); + let token_addr = native_asset::token_address(&asset); + + // Add to registry. + dynamic_field::add(&mut self.id, Key {}, asset); + self.num_native = self.num_native + 1; + + // Now add the coin type. + table::add( + &mut self.coin_types, + CoinTypeKey { + chain: wormhole::state::chain_id(), + addr: external_address::to_bytes(token_addr) + }, + type_name::into_string(type_name::get()) + ); + + // Return the token address. + token_addr + } + + #[test_only] + public fun add_new_native_test_only( + self: &mut TokenRegistry, + metadata: &CoinMetadata + ): ExternalAddress { + add_new_native(self, metadata) + } + + public fun borrow_wrapped( + self: &TokenRegistry + ): &WrappedAsset { + dynamic_field::borrow(&self.id, Key {}) + } + + public(friend) fun borrow_mut_wrapped( + self: &mut TokenRegistry + ): &mut WrappedAsset { + dynamic_field::borrow_mut(&mut self.id, Key {}) + } + + #[test_only] + public fun borrow_mut_wrapped_test_only( + self: &mut TokenRegistry + ): &mut WrappedAsset { + borrow_mut_wrapped(self) + } + + public fun borrow_native( + self: &TokenRegistry + ): &NativeAsset { + dynamic_field::borrow(&self.id, Key {}) + } + + public(friend) fun borrow_mut_native( + self: &mut TokenRegistry + ): &mut NativeAsset { + dynamic_field::borrow_mut(&mut self.id, Key {}) + } + + #[test_only] + public fun borrow_mut_native_test_only( + self: &mut TokenRegistry + ): &mut NativeAsset { + borrow_mut_native(self) + } + + #[test_only] + public fun num_native(self: &TokenRegistry): u64 { + self.num_native + } + + #[test_only] + public fun num_wrapped(self: &TokenRegistry): u64 { + self.num_wrapped + } + + #[test_only] + public fun destroy(registry: TokenRegistry) { + let TokenRegistry { + id, + num_wrapped: _, + num_native: _, + coin_types + } = registry; + object::delete(id); + table::drop(coin_types); + } + + #[test_only] + public fun coin_type_for( + self: &TokenRegistry, + chain: u16, + addr: vector + ): String { + *table::borrow(&self.coin_types, CoinTypeKey { chain, addr }) + } +} + +// In this test, we exercise the various functionalities of TokenRegistry, +// including registering native and wrapped coins via add_new_native, and +// add_new_wrapped, minting/burning/depositing/withdrawing said tokens, and also +// storing metadata about the tokens. +#[test_only] +module token_bridge::token_registry_tests { + use std::type_name::{Self}; + use sui::balance::{Self}; + use sui::coin::{CoinMetadata}; + use sui::test_scenario::{Self}; + use wormhole::external_address::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::asset_meta::{Self}; + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::coin_wrapped_7::{Self, COIN_WRAPPED_7}; + use token_bridge::native_asset::{Self}; + use token_bridge::token_registry::{Self}; + use token_bridge::token_bridge_scenario::{person}; + use token_bridge::wrapped_asset::{Self}; + + struct SCAM_COIN has drop {} + + #[test] + fun test_registered_tokens_native() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize new coin. + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Initialize new token registry. + let registry = + token_registry::new_test_only(test_scenario::ctx(scenario)); + + // Check initial state. + assert!(token_registry::num_native(®istry) == 0, 0); + assert!(token_registry::num_wrapped(®istry) == 0, 0); + + // Register native asset. + let coin_meta = coin_native_10::take_metadata(scenario); + let token_address = + token_registry::add_new_native_test_only( + &mut registry, + &coin_meta, + ); + let expected_token_address = + native_asset::canonical_address(&coin_meta); + assert!(token_address == expected_token_address, 0); + + // mint some native coins, then deposit them into the token registry + let deposit_amount = 69; + let (i, n) = (0, 8); + while (i < n) { + native_asset::deposit_test_only( + token_registry::borrow_mut_native_test_only( + &mut registry, + ), + balance::create_for_testing( + deposit_amount + ) + ); + i = i + 1; + }; + let total_deposited = n * deposit_amount; + { + let asset = + token_registry::borrow_native(®istry); + assert!(native_asset::custody(asset) == total_deposited, 0); + }; + + // Withdraw and check balances. + let withdraw_amount = 420; + let withdrawn = + native_asset::withdraw_test_only( + token_registry::borrow_mut_native_test_only( + &mut registry + ), + withdraw_amount + ); + assert!(balance::value(&withdrawn) == withdraw_amount, 0); + balance::destroy_for_testing(withdrawn); + + let expected_remaining = total_deposited - withdraw_amount; + { + let asset = + token_registry::borrow_native(®istry); + assert!(native_asset::custody(asset) == expected_remaining, 0); + }; + + // Verify registry values. + assert!(token_registry::num_native(®istry) == 1, 0); + assert!(token_registry::num_wrapped(®istry) == 0, 0); + + let verified = token_registry::verified_asset(®istry); + assert!(!token_registry::is_wrapped(&verified), 0); + assert!(token_registry::coin_decimals(&verified) == 10, 0); + assert!(token_registry::token_chain(&verified) == chain_id(), 0); + assert!( + token_registry::token_address(&verified) == expected_token_address, + 0 + ); + + // Check coin type. + let coin_type = + token_registry::coin_type_for( + ®istry, + token_registry::token_chain(&verified), + external_address::to_bytes( + token_registry::token_address(&verified) + ) + ); + assert!( + coin_type == type_name::into_string(type_name::get()), + 0 + ); + + // Clean up. + token_registry::destroy(registry); + coin_native_10::return_metadata(coin_meta); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_registered_tokens_wrapped() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize new coin. + let treasury_cap = + coin_wrapped_7::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Initialize new token registry. + let registry = + token_registry::new_test_only(test_scenario::ctx(scenario)); + + // Check initial state. + assert!(token_registry::num_wrapped(®istry) == 0, 0); + assert!(token_registry::num_native(®istry) == 0, 0); + + let coin_meta = test_scenario::take_shared>(scenario); + + // Register wrapped asset. + let wrapped_token_meta = coin_wrapped_7::token_meta(); + token_registry::add_new_wrapped_test_only( + &mut registry, + wrapped_token_meta, + &mut coin_meta, + treasury_cap, + test_scenario::ctx(scenario) + ); + + test_scenario::return_shared(coin_meta); + + // Mint wrapped coin via `WrappedAsset` several times. + let mint_amount = 420; + let total_minted = balance::zero(); + let (i, n) = (0, 8); + while (i < n) { + let minted = + wrapped_asset::mint_test_only( + token_registry::borrow_mut_wrapped_test_only( + &mut registry, + ), + mint_amount + ); + assert!(balance::value(&minted) == mint_amount, 0); + balance::join(&mut total_minted, minted); + i = i + 1; + }; + + let total_supply = + wrapped_asset::total_supply( + token_registry::borrow_wrapped( + ®istry + ) + ); + assert!(total_supply == balance::value(&total_minted), 0); + + // withdraw, check value, and re-deposit native coins into registry + let burn_amount = 69; + let burned = + wrapped_asset::burn_test_only( + token_registry::borrow_mut_wrapped_test_only(&mut registry), + balance::split(&mut total_minted, burn_amount) + ); + assert!(burned == burn_amount, 0); + + let expected_remaining = total_supply - burn_amount; + let remaining = + wrapped_asset::total_supply( + token_registry::borrow_wrapped( + ®istry + ) + ); + assert!(remaining == expected_remaining, 0); + balance::destroy_for_testing(total_minted); + + // Verify registry values. + assert!(token_registry::num_wrapped(®istry) == 1, 0); + assert!(token_registry::num_native(®istry) == 0, 0); + + + let verified = token_registry::verified_asset(®istry); + assert!(token_registry::is_wrapped(&verified), 0); + assert!(token_registry::coin_decimals(&verified) == 7, 0); + + let wrapped_token_meta = coin_wrapped_7::token_meta(); + assert!( + token_registry::token_chain(&verified) == asset_meta::token_chain(&wrapped_token_meta), + 0 + ); + assert!( + token_registry::token_address(&verified) == asset_meta::token_address(&wrapped_token_meta), + 0 + ); + + // Check coin type. + let coin_type = + token_registry::coin_type_for( + ®istry, + token_registry::token_chain(&verified), + external_address::to_bytes( + token_registry::token_address(&verified) + ) + ); + assert!( + coin_type == type_name::into_string(type_name::get()), + 0 + ); + + + // Clean up. + token_registry::destroy(registry); + asset_meta::destroy(wrapped_token_meta); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = sui::dynamic_field::EFieldAlreadyExists)] + /// In this negative test case, we try to register a native token twice. + fun test_cannot_add_new_native_again() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize new coin. + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Initialize new token registry. + let registry = + token_registry::new_test_only(test_scenario::ctx(scenario)); + + let coin_meta = coin_native_10::take_metadata(scenario); + + // Add new native asset. + token_registry::add_new_native_test_only( + &mut registry, + &coin_meta + ); + + // You shall not pass! + // + // NOTE: We don't have a custom error for this. This will trigger a + // `sui::dynamic_field` error. + token_registry::add_new_native_test_only( + &mut registry, + &coin_meta + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = sui::dynamic_field::EFieldTypeMismatch)] + // In this negative test case, we attempt to deposit a wrapped token into + // a TokenRegistry object, resulting in failure. A wrapped coin can + // only be minted and burned, not deposited. + fun test_cannot_deposit_wrapped_asset() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let treasury_cap = + coin_wrapped_7::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Initialize new token registry. + let registry = + token_registry::new_test_only(test_scenario::ctx(scenario)); + + let coin_meta = test_scenario::take_shared>(scenario); + + token_registry::add_new_wrapped_test_only( + &mut registry, + coin_wrapped_7::token_meta(), + &mut coin_meta, + treasury_cap, + test_scenario::ctx(scenario) + ); + + test_scenario::return_shared(coin_meta); + + // Mint some wrapped coins and attempt to deposit balance. + let minted = + wrapped_asset::mint_test_only( + token_registry::borrow_mut_wrapped_test_only( + &mut registry + ), + 420420420 + ); + + let verified = token_registry::verified_asset(®istry); + assert!(token_registry::is_wrapped(&verified), 0); + + // You shall not pass! + // + // NOTE: We don't have a custom error for this. This will trigger a + // `sui::dynamic_field` error. + native_asset::deposit_test_only( + token_registry::borrow_mut_native_test_only( + &mut registry + ), + minted + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = sui::dynamic_field::EFieldTypeMismatch)] + // In this negative test case, we attempt to deposit a wrapped token into + // a TokenRegistry object, resulting in failure. A wrapped coin can + // only be minted and burned, not deposited. + fun test_cannot_mint_native_asset() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Initialize new token registry. + let registry = + token_registry::new_test_only(test_scenario::ctx(scenario)); + + let coin_meta = coin_native_10::take_metadata(scenario); + token_registry::add_new_native_test_only( + &mut registry, + &coin_meta + ); + + // Show that this asset is not wrapped. + let verified = token_registry::verified_asset(®istry); + assert!(!token_registry::is_wrapped(&verified), 0); + + // You shall not pass! + // + // NOTE: We don't have a custom error for this. This will trigger a + // `sui::dynamic_field` error. + let minted = + wrapped_asset::mint_test_only( + token_registry::borrow_mut_wrapped_test_only( + &mut registry + ), + 420 + ); + + // Clean up. + balance::destroy_for_testing(minted); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = token_registry::E_ALREADY_WRAPPED)] + fun test_cannot_add_new_wrapped_with_same_canonical_info() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize new coin. + let treasury_cap = + coin_wrapped_7::init_and_take_treasury_cap( + scenario, + caller + ); + + // Initialize other coin + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Initialize new token registry. + let registry = + token_registry::new_test_only(test_scenario::ctx(scenario)); + + let coin_meta = test_scenario::take_shared>(scenario); + + // Register wrapped asset. + token_registry::add_new_wrapped_test_only( + &mut registry, + coin_wrapped_7::token_meta(), + &mut coin_meta, + treasury_cap, + test_scenario::ctx(scenario) + ); + + test_scenario::return_shared(coin_meta); + + let coin_meta = coin_native_10::take_metadata(scenario); + let treasury_cap = coin_native_10::take_treasury_cap(scenario); + + // You shall not pass! + token_registry::add_new_wrapped_test_only( + &mut registry, + coin_wrapped_7::token_meta(), + &mut coin_meta, + treasury_cap, + test_scenario::ctx(scenario) + ); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/resources/wrapped_asset.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/resources/wrapped_asset.move new file mode 100644 index 0000000000..7df31c540e --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/resources/wrapped_asset.move @@ -0,0 +1,806 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements two custom types relating to Token Bridge wrapped +/// assets. These assets have been attested from foreign networks, whose +/// metadata is stored in `ForeignInfo`. The Token Bridge contract is the +/// only authority that can mint and burn these assets via `Supply`. +/// +/// See `create_wrapped` and 'token_registry' modules for more details. +module token_bridge::wrapped_asset { + use std::string::{String}; + use sui::balance::{Self, Balance}; + use sui::coin::{Self, TreasuryCap, CoinMetadata}; + use sui::package::{Self, UpgradeCap}; + use wormhole::external_address::{ExternalAddress}; + use wormhole::state::{chain_id}; + + use token_bridge::string_utils; + use token_bridge::asset_meta::{Self, AssetMeta}; + use token_bridge::normalized_amount::{cap_decimals}; + + friend token_bridge::complete_transfer; + friend token_bridge::create_wrapped; + friend token_bridge::token_registry; + friend token_bridge::transfer_tokens; + + /// Token chain ID matching Sui's are not allowed. + const E_SUI_CHAIN: u64 = 0; + /// Canonical token info does match `AssetMeta` payload. + const E_ASSET_META_MISMATCH: u64 = 1; + /// Coin decimals don't match the VAA. + const E_DECIMALS_MISMATCH: u64 = 2; + + /// Container storing foreign asset info. + struct ForeignInfo has store { + token_chain: u16, + token_address: ExternalAddress, + native_decimals: u8, + symbol: String + } + + /// Container managing `ForeignInfo` and `TreasuryCap` for a wrapped asset + /// coin type. + struct WrappedAsset has store { + info: ForeignInfo, + treasury_cap: TreasuryCap, + decimals: u8, + upgrade_cap: UpgradeCap + } + + /// Create new `WrappedAsset`. + /// + /// See `token_registry` module for more info. + public(friend) fun new( + token_meta: AssetMeta, + coin_meta: &mut CoinMetadata, + treasury_cap: TreasuryCap, + upgrade_cap: UpgradeCap + ): WrappedAsset { + // Verify that the upgrade cap is from the same package as coin type. + // This cap should not have been modified prior to creating this asset + // (i.e. should have the default upgrade policy and build version == 1). + wormhole::package_utils::assert_package_upgrade_cap( + &upgrade_cap, + package::compatible_policy(), + 1 + ); + + let ( + token_address, + token_chain, + native_decimals, + symbol, + name + ) = asset_meta::unpack(token_meta); + + // Protect against adding `AssetMeta` which has Sui's chain ID. + assert!(token_chain != chain_id(), E_SUI_CHAIN); + + // Set metadata. + coin::update_name(&treasury_cap, coin_meta, name); + coin::update_symbol(&treasury_cap, coin_meta, string_utils::to_ascii(&symbol)); + + let decimals = cap_decimals(native_decimals); + + // Ensure that the `C` type has the right number of decimals. This is + // the only field in the coinmeta that cannot be changed after the fact, + // so we expect to receive one that already has the correct decimals + // set. + assert!(decimals == coin::get_decimals(coin_meta), E_DECIMALS_MISMATCH); + + let info = + ForeignInfo { + token_address, + token_chain, + native_decimals, + symbol + }; + + WrappedAsset { + info, + treasury_cap, + decimals, + upgrade_cap + } + } + + #[test_only] + public fun new_test_only( + token_meta: AssetMeta, + coin_meta: &mut CoinMetadata, + treasury_cap: TreasuryCap, + upgrade_cap: UpgradeCap + ): WrappedAsset { + new(token_meta, coin_meta, treasury_cap, upgrade_cap) + } + + /// Update existing `ForeignInfo` using new `AssetMeta`. + /// + /// See `token_registry` module for more info. + public(friend) fun update_metadata( + self: &mut WrappedAsset, + coin_meta: &mut CoinMetadata, + token_meta: AssetMeta + ) { + // NOTE: We ignore `native_decimals` because we do not enforce that + // an asset's decimals on a foreign network needs to stay the same. + let ( + token_address, + token_chain, + _native_decimals, + symbol, + name + ) = asset_meta::unpack(token_meta); + + // Verify canonical token info. Also check that the native decimals + // have not changed (because changing this info is not desirable, as + // this change means the supply changed on its native network). + // + // NOTE: This implicitly verifies that `token_chain` is not Sui's + // because this was checked already when the asset was first added. + let (expected_chain, expected_address) = canonical_info(self); + assert!( + ( + token_chain == expected_chain && + token_address == expected_address + ), + E_ASSET_META_MISMATCH + ); + + // Finally only update the name and symbol. + self.info.symbol = symbol; + coin::update_name(&self.treasury_cap, coin_meta, name); + coin::update_symbol(&self.treasury_cap, coin_meta, string_utils::to_ascii(&symbol)); + } + + #[test_only] + public fun update_metadata_test_only( + self: &mut WrappedAsset, + coin_meta: &mut CoinMetadata, + token_meta: AssetMeta + ) { + update_metadata(self, coin_meta, token_meta) + } + + /// Retrieve immutable reference to `ForeignInfo`. + public fun info(self: &WrappedAsset): &ForeignInfo { + &self.info + } + + /// Retrieve canonical token chain ID from `ForeignInfo`. + public fun token_chain(info: &ForeignInfo): u16 { + info.token_chain + } + + /// Retrieve canonical token address from `ForeignInfo`. + public fun token_address(info: &ForeignInfo): ExternalAddress { + info.token_address + } + + /// Retrieve decimal amount from `ForeignInfo`. + /// + /// NOTE: This is for informational purposes. This decimal amount is not + /// used for any calculations. + public fun native_decimals(info: &ForeignInfo): u8 { + info.native_decimals + } + + /// Retrieve asset's symbol (UTF-8) from `ForeignMetadata`. + /// + /// NOTE: This value can be updated. + public fun symbol(info: &ForeignInfo): String { + info.symbol + } + + /// Retrieve total minted supply. + public fun total_supply(self: &WrappedAsset): u64 { + coin::total_supply(&self.treasury_cap) + } + + /// Retrieve decimals for this wrapped asset. For any asset whose native + /// decimals is greater than the cap (8), this will be 8. + /// + /// See `normalized_amount` module for more info. + public fun decimals(self: &WrappedAsset): u8 { + self.decimals + } + + /// Retrieve canonical token chain ID and token address. + public fun canonical_info( + self: &WrappedAsset + ): (u16, ExternalAddress) { + (self.info.token_chain, self.info.token_address) + } + + /// Burn a given `Balance`. `Balance` originates from an outbound token + /// transfer for a wrapped asset. + /// + /// See `transfer_tokens` module for more info. + public(friend) fun burn( + self: &mut WrappedAsset, + burned: Balance + ): u64 { + balance::decrease_supply(coin::supply_mut(&mut self.treasury_cap), burned) + } + + #[test_only] + public fun burn_test_only( + self: &mut WrappedAsset, + burned: Balance + ): u64 { + burn(self, burned) + } + + /// Mint a given amount. This amount is determined by an inbound token + /// transfer payload for a wrapped asset. + /// + /// See `complete_transfer` module for more info. + public(friend) fun mint( + self: &mut WrappedAsset, + amount: u64 + ): Balance { + coin::mint_balance(&mut self.treasury_cap, amount) + } + + #[test_only] + public fun mint_test_only( + self: &mut WrappedAsset, + amount: u64 + ): Balance { + mint(self, amount) + } + + #[test_only] + public fun destroy(asset: WrappedAsset) { + let WrappedAsset { + info, + treasury_cap, + decimals: _, + upgrade_cap + } = asset; + sui::test_utils::destroy(treasury_cap); + + let ForeignInfo { + token_chain: _, + token_address: _, + native_decimals: _, + symbol: _ + } = info; + + sui::package::make_immutable(upgrade_cap); + } +} + +#[test_only] +module token_bridge::wrapped_asset_tests { + use std::string::{Self}; + use sui::balance::{Self}; + use sui::coin::{Self, CoinMetadata}; + use sui::object::{Self}; + use sui::package::{Self}; + use sui::test_scenario::{Self}; + use wormhole::external_address::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::asset_meta::{Self}; + use token_bridge::string_utils; + use token_bridge::coin_native_10::{COIN_NATIVE_10, Self}; + use token_bridge::coin_wrapped_12::{COIN_WRAPPED_12, Self}; + use token_bridge::coin_wrapped_7::{COIN_WRAPPED_7, Self}; + use token_bridge::token_bridge_scenario::{person}; + use token_bridge::wrapped_asset::{Self}; + + #[test] + fun test_wrapped_asset_7() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let parsed_meta = coin_wrapped_7::token_meta(); + let expected_token_chain = asset_meta::token_chain(&parsed_meta); + let expected_token_address = asset_meta::token_address(&parsed_meta); + let expected_native_decimals = + asset_meta::native_decimals(&parsed_meta); + let expected_symbol = asset_meta::symbol(&parsed_meta); + let expected_name = asset_meta::name(&parsed_meta); + + // Publish coin. + let treasury_cap = + coin_wrapped_7::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Upgrade cap belonging to coin type. + let upgrade_cap = + package::test_publish( + object::id_from_address(@token_bridge), + test_scenario::ctx(scenario) + ); + + let coin_meta: CoinMetadata = test_scenario::take_shared(scenario); + + // Make new. + let asset = + wrapped_asset::new_test_only( + parsed_meta, + &mut coin_meta, + treasury_cap, + upgrade_cap + ); + + // Verify members. + let info = wrapped_asset::info(&asset); + assert!( + wrapped_asset::token_chain(info) == expected_token_chain, + 0 + ); + assert!( + wrapped_asset::token_address(info) == expected_token_address, + 0 + ); + assert!( + wrapped_asset::native_decimals(info) == expected_native_decimals, + 0 + ); + assert!(coin::get_symbol(&coin_meta) == string_utils::to_ascii(&expected_symbol), 0); + assert!(coin::get_name(&coin_meta) == expected_name, 0); + assert!(wrapped_asset::total_supply(&asset) == 0, 0); + + let (token_chain, token_address) = + wrapped_asset::canonical_info(&asset); + assert!(token_chain == expected_token_chain, 0); + assert!(token_address == expected_token_address, 0); + + // Decimals are read from `CoinMetadata`, but in this case will agree + // with the value encoded in the VAA. + assert!(wrapped_asset::decimals(&asset) == expected_native_decimals, 0); + assert!(coin::get_decimals(&coin_meta) == expected_native_decimals, 0); + + // Change name and symbol for update. + let new_symbol = std::ascii::into_bytes(coin::get_symbol(&coin_meta)); + + std::vector::append(&mut new_symbol, b"??? and profit"); + assert!(new_symbol != *string::bytes(&expected_symbol), 0); + + let new_name = coin::get_name(&coin_meta); + string::append(&mut new_name, string::utf8(b"??? and profit")); + assert!(new_name != expected_name, 0); + + let updated_meta = + asset_meta::new( + expected_token_address, + expected_token_chain, + expected_native_decimals, + string::utf8(new_symbol), + new_name + ); + + // Update metadata now. + wrapped_asset::update_metadata_test_only(&mut asset, &mut coin_meta, updated_meta); + + assert!(coin::get_symbol(&coin_meta) == std::ascii::string(new_symbol), 0); + assert!(coin::get_name(&coin_meta) == new_name, 0); + + // Try to mint. + let mint_amount = 420; + let collected = balance::zero(); + let (i, n) = (0, 8); + while (i < n) { + let minted = + wrapped_asset::mint_test_only(&mut asset, mint_amount); + assert!(balance::value(&minted) == mint_amount, 0); + balance::join(&mut collected, minted); + i = i + 1; + }; + assert!(balance::value(&collected) == n * mint_amount, 0); + assert!( + wrapped_asset::total_supply(&asset) == balance::value(&collected), + 0 + ); + + // Now try to burn. + let burn_amount = 69; + let i = 0; + while (i < n) { + let burned = balance::split(&mut collected, burn_amount); + let check_amount = + wrapped_asset::burn_test_only(&mut asset, burned); + assert!(check_amount == burn_amount, 0); + i = i + 1; + }; + let remaining = n * mint_amount - n * burn_amount; + assert!(wrapped_asset::total_supply(&asset) == remaining, 0); + assert!(balance::value(&collected) == remaining, 0); + + test_scenario::return_shared(coin_meta); + + // Clean up. + balance::destroy_for_testing(collected); + wrapped_asset::destroy(asset); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_wrapped_asset_12() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let parsed_meta = coin_wrapped_12::token_meta(); + let expected_token_chain = asset_meta::token_chain(&parsed_meta); + let expected_token_address = asset_meta::token_address(&parsed_meta); + let expected_native_decimals = + asset_meta::native_decimals(&parsed_meta); + let expected_symbol = asset_meta::symbol(&parsed_meta); + let expected_name = asset_meta::name(&parsed_meta); + + // Publish coin. + let treasury_cap = + coin_wrapped_12::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Upgrade cap belonging to coin type. + let upgrade_cap = + package::test_publish( + object::id_from_address(@token_bridge), + test_scenario::ctx(scenario) + ); + + let coin_meta: CoinMetadata = test_scenario::take_shared(scenario); + + // Make new. + let asset = + wrapped_asset::new_test_only( + parsed_meta, + &mut coin_meta, + treasury_cap, + upgrade_cap + ); + + // Verify members. + let info = wrapped_asset::info(&asset); + assert!( + wrapped_asset::token_chain(info) == expected_token_chain, + 0 + ); + assert!( + wrapped_asset::token_address(info) == expected_token_address, + 0 + ); + assert!( + wrapped_asset::native_decimals(info) == expected_native_decimals, + 0 + ); + assert!(coin::get_symbol(&coin_meta) == string_utils::to_ascii(&expected_symbol), 0); + assert!(coin::get_name(&coin_meta) == expected_name, 0); + assert!(wrapped_asset::total_supply(&asset) == 0, 0); + + let (token_chain, token_address) = + wrapped_asset::canonical_info(&asset); + assert!(token_chain == expected_token_chain, 0); + assert!(token_address == expected_token_address, 0); + + // Decimals are read from `CoinMetadata`, but in this case will not + // agree with the value encoded in the VAA. + assert!(wrapped_asset::decimals(&asset) == 8, 0); + assert!( + coin::get_decimals(&coin_meta) == wrapped_asset::decimals(&asset), + 0 + ); + assert!(wrapped_asset::decimals(&asset) != expected_native_decimals, 0); + + // Change name and symbol for update. + let new_symbol = std::ascii::into_bytes(coin::get_symbol(&coin_meta)); + + std::vector::append(&mut new_symbol, b"??? and profit"); + assert!(new_symbol != *string::bytes(&expected_symbol), 0); + + let new_name = coin::get_name(&coin_meta); + string::append(&mut new_name, string::utf8(b"??? and profit")); + assert!(new_name != expected_name, 0); + + let updated_meta = + asset_meta::new( + expected_token_address, + expected_token_chain, + expected_native_decimals, + string::utf8(new_symbol), + new_name + ); + + // Update metadata now. + wrapped_asset::update_metadata_test_only(&mut asset, &mut coin_meta, updated_meta); + + assert!(coin::get_symbol(&coin_meta) == std::ascii::string(new_symbol), 0); + assert!(coin::get_name(&coin_meta) == new_name, 0); + + // Try to mint. + let mint_amount = 420; + let collected = balance::zero(); + let (i, n) = (0, 8); + while (i < n) { + let minted = + wrapped_asset::mint_test_only(&mut asset, mint_amount); + assert!(balance::value(&minted) == mint_amount, 0); + balance::join(&mut collected, minted); + i = i + 1; + }; + assert!(balance::value(&collected) == n * mint_amount, 0); + assert!( + wrapped_asset::total_supply(&asset) == balance::value(&collected), + 0 + ); + + // Now try to burn. + let burn_amount = 69; + let i = 0; + while (i < n) { + let burned = balance::split(&mut collected, burn_amount); + let check_amount = + wrapped_asset::burn_test_only(&mut asset, burned); + assert!(check_amount == burn_amount, 0); + i = i + 1; + }; + let remaining = n * mint_amount - n * burn_amount; + assert!(wrapped_asset::total_supply(&asset) == remaining, 0); + assert!(balance::value(&collected) == remaining, 0); + + // Clean up. + balance::destroy_for_testing(collected); + wrapped_asset::destroy(asset); + test_scenario::return_shared(coin_meta); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wrapped_asset::E_SUI_CHAIN)] + // In this negative test case, we attempt to register a native coin as a + // wrapped coin. + fun test_cannot_new_sui_chain() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize new coin type. + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Sui's chain ID is not allowed. + let invalid_meta = + asset_meta::new( + external_address::default(), + chain_id(), + 10, + string::utf8(b""), + string::utf8(b"") + ); + + // Upgrade cap belonging to coin type. + let upgrade_cap = + package::test_publish( + object::id_from_address(@token_bridge), + test_scenario::ctx(scenario) + ); + + let treasury_cap = test_scenario::take_shared>(scenario); + let coin_meta = test_scenario::take_shared>(scenario); + + // You shall not pass! + let asset = + wrapped_asset::new_test_only( + invalid_meta, + &mut coin_meta, + treasury_cap, + upgrade_cap + ); + + // Clean up. + wrapped_asset::destroy(asset); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wrapped_asset::E_ASSET_META_MISMATCH)] + /// In this negative test case, we attempt to update with a mismatching + /// chain. + fun test_cannot_update_metadata_asset_meta_mismatch_token_address() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let parsed_meta = coin_wrapped_12::token_meta(); + let expected_token_chain = asset_meta::token_chain(&parsed_meta); + let expected_token_address = asset_meta::token_address(&parsed_meta); + let expected_native_decimals = + asset_meta::native_decimals(&parsed_meta); + + // Publish coin. + let treasury_cap = + coin_wrapped_12::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Upgrade cap belonging to coin type. + let upgrade_cap = + package::test_publish( + object::id_from_address(@token_bridge), + test_scenario::ctx(scenario) + ); + + let coin_meta = test_scenario::take_shared(scenario); + + // Make new. + let asset = + wrapped_asset::new_test_only( + parsed_meta, + &mut coin_meta, + treasury_cap, + upgrade_cap + ); + + let invalid_meta = + asset_meta::new( + external_address::default(), + expected_token_chain, + expected_native_decimals, + string::utf8(b""), + string::utf8(b""), + ); + assert!( + asset_meta::token_address(&invalid_meta) != expected_token_address, + 0 + ); + assert!( + asset_meta::token_chain(&invalid_meta) == expected_token_chain, + 0 + ); + assert!( + asset_meta::native_decimals(&invalid_meta) == expected_native_decimals, + 0 + ); + + // You shall not pass! + wrapped_asset::update_metadata_test_only(&mut asset, &mut coin_meta, invalid_meta); + + // Clean up. + wrapped_asset::destroy(asset); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wrapped_asset::E_ASSET_META_MISMATCH)] + /// In this negative test case, we attempt to update with a mismatching + /// chain. + fun test_cannot_update_metadata_asset_meta_mismatch_token_chain() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let parsed_meta = coin_wrapped_12::token_meta(); + let expected_token_chain = asset_meta::token_chain(&parsed_meta); + let expected_token_address = asset_meta::token_address(&parsed_meta); + let expected_native_decimals = + asset_meta::native_decimals(&parsed_meta); + + // Publish coin. + let treasury_cap = + coin_wrapped_12::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Upgrade cap belonging to coin type. + let upgrade_cap = + package::test_publish( + object::id_from_address(@token_bridge), + test_scenario::ctx(scenario) + ); + + let coin_meta = test_scenario::take_shared(scenario); + + // Make new. + let asset = + wrapped_asset::new_test_only( + parsed_meta, + &mut coin_meta, + treasury_cap, + upgrade_cap + ); + + let invalid_meta = + asset_meta::new( + expected_token_address, + chain_id(), + expected_native_decimals, + string::utf8(b""), + string::utf8(b""), + ); + assert!( + asset_meta::token_address(&invalid_meta) == expected_token_address, + 0 + ); + assert!( + asset_meta::token_chain(&invalid_meta) != expected_token_chain, + 0 + ); + assert!( + asset_meta::native_decimals(&invalid_meta) == expected_native_decimals, + 0 + ); + + // You shall not pass! + wrapped_asset::update_metadata_test_only(&mut asset, &mut coin_meta, invalid_meta); + + // Clean up. + wrapped_asset::destroy(asset); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = wormhole::package_utils::E_INVALID_UPGRADE_CAP + )] + fun test_cannot_new_upgrade_cap_mismatch() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Publish coin. + let treasury_cap = + coin_wrapped_12::init_and_take_treasury_cap( + scenario, + caller + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Upgrade cap belonging to coin type. + let upgrade_cap = + package::test_publish( + object::id_from_address(@0xbadc0de), + test_scenario::ctx(scenario) + ); + + let coin_meta = test_scenario::take_shared(scenario); + + // You shall not pass! + let asset = + wrapped_asset::new_test_only( + coin_wrapped_12::token_meta(), + &mut coin_meta, + treasury_cap, + upgrade_cap + ); + + // Clean up. + wrapped_asset::destroy(asset); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/setup.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/setup.move new file mode 100644 index 0000000000..89beaf418b --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/setup.move @@ -0,0 +1,78 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements the mechanism to publish the Token Bridge contract +/// and initialize `State` as a shared object. +module token_bridge::setup { + use sui::object::{Self, UID}; + use sui::package::{Self, UpgradeCap}; + use sui::transfer::{Self}; + use sui::tx_context::{Self, TxContext}; + use wormhole::emitter::{EmitterCap}; + + use token_bridge::state::{Self}; + + /// Capability created at `init`, which will be destroyed once + /// `init_and_share_state` is called. This ensures only the deployer can + /// create the shared `State`. + struct DeployerCap has key, store { + id: UID + } + + /// Called automatically when module is first published. Transfers + /// `DeployerCap` to sender. + /// + /// Only `setup::init_and_share_state` requires `DeployerCap`. + fun init(ctx: &mut TxContext) { + let deployer = DeployerCap { id: object::new(ctx) }; + transfer::transfer(deployer, tx_context::sender(ctx)); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + // NOTE: This exists to mock up sui::package for proposed upgrades. + use sui::package::{Self}; + + init(ctx); + + // This will be created and sent to the transaction sender + // automatically when the contract is published. + transfer::public_transfer( + package::test_publish(object::id_from_address(@token_bridge), ctx), + tx_context::sender(ctx) + ); + } + + #[allow(lint(share_owned))] + /// Only the owner of the `DeployerCap` can call this method. This + /// method destroys the capability and shares the `State` object. + public fun complete( + deployer: DeployerCap, + upgrade_cap: UpgradeCap, + emitter_cap: EmitterCap, + governance_chain: u16, + governance_contract: vector, + ctx: &mut TxContext + ) { + wormhole::package_utils::assert_package_upgrade_cap( + &upgrade_cap, + package::compatible_policy(), + 1 + ); + + // Destroy deployer cap. + let DeployerCap { id } = deployer; + object::delete(id); + + // Share new state. + transfer::public_share_object( + state::new( + emitter_cap, + upgrade_cap, + governance_chain, + wormhole::external_address::new_nonzero( + wormhole::bytes32::from_bytes(governance_contract) + ), + ctx + )); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/state.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/state.move new file mode 100644 index 0000000000..fbe8dab4a4 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/state.move @@ -0,0 +1,396 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements the global state variables for Token Bridge as a +/// shared object. The `State` object is used to perform anything that requires +/// access to data that defines the Token Bridge contract. Examples of which are +/// accessing registered assets and verifying `VAA` intended for Token Bridge by +/// checking the emitter against its own registered emitters. +module token_bridge::state { + use sui::object::{Self, ID, UID}; + use sui::package::{UpgradeCap, UpgradeReceipt, UpgradeTicket}; + use sui::table::{Self, Table}; + use sui::tx_context::{TxContext}; + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::consumed_vaas::{Self, ConsumedVAAs}; + use wormhole::emitter::{EmitterCap}; + use wormhole::external_address::{ExternalAddress}; + use wormhole::package_utils::{Self}; + use wormhole::publish_message::{MessageTicket}; + + use token_bridge::token_registry::{Self, TokenRegistry, VerifiedAsset}; + use token_bridge::version_control::{Self}; + + /// Build digest does not agree with current implementation. + const E_INVALID_BUILD_DIGEST: u64 = 0; + /// Specified version does not match this build's version. + const E_VERSION_MISMATCH: u64 = 1; + /// Emitter has already been used to emit Wormhole messages. + const E_USED_EMITTER: u64 = 2; + + friend token_bridge::attest_token; + friend token_bridge::complete_transfer; + friend token_bridge::complete_transfer_with_payload; + friend token_bridge::create_wrapped; + friend token_bridge::migrate; + friend token_bridge::register_chain; + friend token_bridge::setup; + friend token_bridge::transfer_tokens; + friend token_bridge::transfer_tokens_with_payload; + friend token_bridge::upgrade_contract; + friend token_bridge::vaa; + + /// Capability reflecting that the current build version is used to invoke + /// state methods. + struct LatestOnly has drop {} + + /// Container for all state variables for Token Bridge. + struct State has key, store { + id: UID, + + /// Governance chain ID. + governance_chain: u16, + + /// Governance contract address. + governance_contract: ExternalAddress, + + /// Set of consumed VAA hashes. + consumed_vaas: ConsumedVAAs, + + /// Emitter capability required to publish Wormhole messages. + emitter_cap: EmitterCap, + + /// Registry for foreign Token Bridge contracts. + emitter_registry: Table, + + /// Registry for native and wrapped assets. + token_registry: TokenRegistry, + + /// Upgrade capability. + upgrade_cap: UpgradeCap + } + + /// Create new `State`. This is only executed using the `setup` module. + public(friend) fun new( + emitter_cap: EmitterCap, + upgrade_cap: UpgradeCap, + governance_chain: u16, + governance_contract: ExternalAddress, + ctx: &mut TxContext + ): State { + assert!(wormhole::emitter::sequence(&emitter_cap) == 0, E_USED_EMITTER); + + let state = State { + id: object::new(ctx), + governance_chain, + governance_contract, + consumed_vaas: consumed_vaas::new(ctx), + emitter_cap, + emitter_registry: table::new(ctx), + token_registry: token_registry::new(ctx), + upgrade_cap + }; + + // Set first version and initialize package info. This will be used for + // emitting information of successful migrations. + let upgrade_cap = &state.upgrade_cap; + package_utils::init_package_info( + &mut state.id, + version_control::current_version(), + upgrade_cap + ); + + state + } + + //////////////////////////////////////////////////////////////////////////// + // + // Simple Getters + // + // These methods do not require `LatestOnly` for access. Anyone is free to + // access these values. + // + //////////////////////////////////////////////////////////////////////////// + + /// Retrieve governance module name. + public fun governance_module(): Bytes32 { + // A.K.A. "TokenBridge". + bytes32::new( + x"000000000000000000000000000000000000000000546f6b656e427269646765" + ) + } + + /// Retrieve governance chain ID, which is governance's emitter chain ID. + public fun governance_chain(self: &State): u16 { + self.governance_chain + } + + /// Retrieve governance emitter address. + public fun governance_contract(self: &State): ExternalAddress { + self.governance_contract + } + + /// Retrieve immutable reference to `TokenRegistry`. + public fun borrow_token_registry( + self: &State + ): &TokenRegistry { + &self.token_registry + } + + public fun borrow_emitter_registry( + self: &State + ): &Table { + &self.emitter_registry + } + + public fun verified_asset( + self: &State + ): VerifiedAsset { + token_registry::assert_has(&self.token_registry); + token_registry::verified_asset(&self.token_registry) + } + + #[test_only] + public fun borrow_mut_token_registry_test_only( + self: &mut State + ): &mut TokenRegistry { + borrow_mut_token_registry(&assert_latest_only(self), self) + } + + #[test_only] + public fun migrate_version_test_only( + self: &mut State, + old_version: Old, + new_version: New + ) { + wormhole::package_utils::update_version_type_test_only( + &mut self.id, + old_version, + new_version + ); + } + + #[test_only] + public fun test_upgrade(self: &mut State) { + let test_digest = bytes32::from_bytes(b"new build"); + let ticket = authorize_upgrade(self, test_digest); + let receipt = sui::package::test_upgrade(ticket); + commit_upgrade(self, receipt); + } + + #[test_only] + public fun reverse_migrate_version(self: &mut State) { + package_utils::update_version_type_test_only( + &mut self.id, + version_control::current_version(), + version_control::previous_version() + ); + } + + //////////////////////////////////////////////////////////////////////////// + // + // Privileged `State` Access + // + // This section of methods require a `LatestOnly`, which can only be + // created within the Token Bridge package. This capability allows special + // access to the `State` object where we require that the latest build is + // used for these interactions. + // + // NOTE: A lot of these methods are still marked as `(friend)` as a safety + // precaution. When a package is upgraded, friend modifiers can be + // removed. + // + //////////////////////////////////////////////////////////////////////////// + + /// Obtain a capability to interact with `State` methods. This method checks + /// that we are running the current build. + /// + /// NOTE: This method allows caching the current version check so we avoid + /// multiple checks to dynamic fields. + public(friend) fun assert_latest_only(self: &State): LatestOnly { + package_utils::assert_version( + &self.id, + version_control::current_version() + ); + + LatestOnly {} + } + + /// Obtain a capability to interact with `State` methods. This method checks + /// that we are running the current build and that the specified `Version` + /// equals the current version. This method is useful when external modules + /// invoke Token Bridge and we need to check that the external module's + /// version is up-to-date (e.g. `create_wrapped::prepare_registration`). + /// + /// NOTE: This method allows caching the current version check so we avoid + /// multiple checks to dynamic fields. + public(friend) fun assert_latest_only_specified( + self: &State + ): LatestOnly { + use std::type_name::{get}; + + // Explicitly check the type names. + let current_type = + package_utils::type_of_version(version_control::current_version()); + assert!(current_type == get(), E_VERSION_MISMATCH); + + assert_latest_only(self) + } + + /// Store `VAA` hash as a way to claim a VAA. This method prevents a VAA + /// from being replayed. + public(friend) fun borrow_mut_consumed_vaas( + _: &LatestOnly, + self: &mut State + ): &mut ConsumedVAAs { + borrow_mut_consumed_vaas_unchecked(self) + } + + /// Store `VAA` hash as a way to claim a VAA. This method prevents a VAA + /// from being replayed. + /// + /// NOTE: This method does not require `LatestOnly`. Only methods in the + /// `upgrade_contract` module requires this to be unprotected to prevent + /// a corrupted upgraded contract from bricking upgradability. + public(friend) fun borrow_mut_consumed_vaas_unchecked( + self: &mut State + ): &mut ConsumedVAAs { + &mut self.consumed_vaas + } + + /// Publish Wormhole message using Token Bridge's `EmitterCap`. + public(friend) fun prepare_wormhole_message( + _: &LatestOnly, + self: &mut State, + nonce: u32, + payload: vector + ): MessageTicket { + wormhole::publish_message::prepare_message( + &mut self.emitter_cap, + nonce, + payload, + ) + } + + /// Retrieve mutable reference to `TokenRegistry`. + public(friend) fun borrow_mut_token_registry( + _: &LatestOnly, + self: &mut State + ): &mut TokenRegistry { + &mut self.token_registry + } + + public(friend) fun borrow_mut_emitter_registry( + _: &LatestOnly, + self: &mut State + ): &mut Table { + &mut self.emitter_registry + } + + public(friend) fun current_package(_: &LatestOnly, self: &State): ID { + package_utils::current_package(&self.id) + } + + //////////////////////////////////////////////////////////////////////////// + // + // Upgradability + // + // A special space that controls upgrade logic. These methods are invoked + // via the `upgrade_contract` module. + // + // Also in this section is managing contract migrations, which uses the + // `migrate` module to officially roll state access to the latest build. + // Only those methods that require `LatestOnly` will be affected by an + // upgrade. + // + //////////////////////////////////////////////////////////////////////////// + + /// Issue an `UpgradeTicket` for the upgrade. + /// + /// NOTE: The Sui VM performs a check that this method is executed from the + /// latest published package. If someone were to try to execute this using + /// a stale build, the transaction will revert with `PackageUpgradeError`, + /// specifically `PackageIDDoesNotMatch`. + public(friend) fun authorize_upgrade( + self: &mut State, + package_digest: Bytes32 + ): UpgradeTicket { + let cap = &mut self.upgrade_cap; + package_utils::authorize_upgrade(&mut self.id, cap, package_digest) + } + + /// Finalize the upgrade that ran to produce the given `receipt`. + /// + /// NOTE: The Sui VM performs a check that this method is executed from the + /// latest published package. If someone were to try to execute this using + /// a stale build, the transaction will revert with `PackageUpgradeError`, + /// specifically `PackageIDDoesNotMatch`. + public(friend) fun commit_upgrade( + self: &mut State, + receipt: UpgradeReceipt + ): (ID, ID) { + let cap = &mut self.upgrade_cap; + package_utils::commit_upgrade(&mut self.id, cap, receipt) + } + + /// Method executed by the `migrate` module to roll access from one package + /// to another. This method will be called from the upgraded package. + public(friend) fun migrate_version(self: &mut State) { + package_utils::migrate_version( + &mut self.id, + version_control::previous_version(), + version_control::current_version() + ); + } + + /// As a part of the migration, we verify that the upgrade contract VAA's + /// encoded package digest used in `migrate` equals the one used to conduct + /// the upgrade. + public(friend) fun assert_authorized_digest( + _: &LatestOnly, + self: &State, + digest: Bytes32 + ) { + let authorized = package_utils::authorized_digest(&self.id); + assert!(digest == authorized, E_INVALID_BUILD_DIGEST); + } + + //////////////////////////////////////////////////////////////////////////// + // + // Special State Interaction via Migrate + // + // A VERY special space that manipulates `State` via calling `migrate`. + // + // PLEASE KEEP ANY METHODS HERE AS FRIENDS. We want the ability to remove + // these for future builds. + // + //////////////////////////////////////////////////////////////////////////// + + /// This method is used to make modifications to `State` when `migrate` is + /// called. This method name should change reflecting which version this + /// contract is migrating to. + /// + /// NOTE: Please keep this method as public(friend) because we never want + /// to expose this method as a public method. + public(friend) fun migrate__v__0_2_0(_self: &mut State) { + // Intentionally do nothing. + } + + #[test_only] + /// Bloody hack. + /// + /// This method is used to set up tests where we migrate to a new version, + /// which is meant to test that modules protected by version control will + /// break. + public fun reverse_migrate__v__dummy(_self: &mut State) { + // Intentionally do nothing. + } + + //////////////////////////////////////////////////////////////////////////// + // + // Deprecated + // + // Dumping grounds for old structs and methods. These things should not + // be used in future builds. + // + //////////////////////////////////////////////////////////////////////////// +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/coin_native_10.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/coin_native_10.move new file mode 100644 index 0000000000..c87282a157 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/coin_native_10.move @@ -0,0 +1,165 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +module token_bridge::coin_native_10 { + use std::option::{Self}; + use sui::balance::{Self, Balance}; + use sui::coin::{Self, CoinMetadata, TreasuryCap}; + use sui::test_scenario::{Self, Scenario}; + use sui::transfer::{Self}; + use sui::tx_context::{TxContext}; + + use token_bridge::native_asset::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_registry::{Self}; + + struct COIN_NATIVE_10 has drop {} + + // This module creates a Sui-native token for testing purposes, + // for example in complete_transfer, where we create a native coin, + // mint some and deposit in the token bridge, then complete transfer + // and ultimately transfer a portion of those native coins to a recipient. + fun init(coin_witness: COIN_NATIVE_10, ctx: &mut TxContext) { + let ( + treasury_cap, + coin_metadata + ) = + coin::create_currency( + coin_witness, + 10, + b"DEC10", + b"Decimals 10", + b"Coin with 10 decimals for testing purposes.", + option::none(), + ctx + ); + + // Allow us to mutate metadata if we need. + transfer::public_share_object(coin_metadata); + + // Give everyone access to `TrasuryCap`. + transfer::public_share_object(treasury_cap); + } + + #[test_only] + /// For a test scenario, register this native asset. + /// + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_and_register(scenario: &mut Scenario, caller: address) { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Publish coin. + init(COIN_NATIVE_10 {}, test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + let coin_meta = take_metadata(scenario); + + // Register asset. + let registry = + state::borrow_mut_token_registry_test_only(&mut token_bridge_state); + token_registry::add_new_native_test_only(registry, &coin_meta); + + // Clean up. + return_state(token_bridge_state); + return_metadata(coin_meta); + } + + #[test_only] + public fun init_register_and_mint( + scenario: &mut Scenario, + caller: address, + amount: u64 + ): Balance { + // First publish and register. + init_and_register(scenario, caller); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Mint. + balance::create_for_testing(amount) + } + + #[test_only] + public fun init_register_and_deposit( + scenario: &mut Scenario, + caller: address, + amount: u64 + ) { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + + let minted = init_register_and_mint(scenario, caller, amount); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + native_asset::deposit_test_only( + token_registry::borrow_mut_native_test_only( + state::borrow_mut_token_registry_test_only( + &mut token_bridge_state + ) + ), + minted + ); + + return_state(token_bridge_state); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_NATIVE_10 {}, ctx); + } + + public fun take_metadata( + scenario: &Scenario + ): CoinMetadata { + test_scenario::take_shared(scenario) + } + + public fun return_metadata( + metadata: CoinMetadata + ) { + test_scenario::return_shared(metadata); + } + + public fun take_treasury_cap( + scenario: &Scenario + ): TreasuryCap { + test_scenario::take_shared(scenario) + } + + public fun return_treasury_cap( + treasury_cap: TreasuryCap + ) { + test_scenario::return_shared(treasury_cap); + } + + public fun take_globals( + scenario: &Scenario + ): ( + TreasuryCap, + CoinMetadata + ) { + ( + take_treasury_cap(scenario), + take_metadata(scenario) + ) + } + + public fun return_globals( + treasury_cap: TreasuryCap, + metadata: CoinMetadata + ) { + return_treasury_cap(treasury_cap); + return_metadata(metadata); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/coin_native_4.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/coin_native_4.move new file mode 100644 index 0000000000..889d036200 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/coin_native_4.move @@ -0,0 +1,165 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +module token_bridge::coin_native_4 { + use std::option::{Self}; + use sui::balance::{Self, Balance}; + use sui::coin::{Self, CoinMetadata, TreasuryCap}; + use sui::test_scenario::{Self, Scenario}; + use sui::transfer::{Self}; + use sui::tx_context::{TxContext}; + + use token_bridge::native_asset::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_registry::{Self}; + + struct COIN_NATIVE_4 has drop {} + + // This module creates a Sui-native token for testing purposes, + // for example in complete_transfer, where we create a native coin, + // mint some and deposit in the token bridge, then complete transfer + // and ultimately transfer a portion of those native coins to a recipient. + fun init(coin_witness: COIN_NATIVE_4, ctx: &mut TxContext) { + let ( + treasury_cap, + coin_metadata + ) = + coin::create_currency( + coin_witness, + 4, + b"DEC4", + b"Decimals 4", + b"Coin with 4 decimals for testing purposes.", + option::none(), + ctx + ); + + // Let's make the metadata shared. + transfer::public_share_object(coin_metadata); + + // Give everyone access to `TrasuryCap`. + transfer::public_share_object(treasury_cap); + } + + #[test_only] + /// For a test scenario, register this native asset. + /// + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_and_register(scenario: &mut Scenario, caller: address) { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Publish coin. + init(COIN_NATIVE_4 {}, test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + let coin_meta = take_metadata(scenario); + + // Register asset. + let registry = + state::borrow_mut_token_registry_test_only(&mut token_bridge_state); + token_registry::add_new_native_test_only(registry, &coin_meta); + + // Clean up. + return_state(token_bridge_state); + return_metadata(coin_meta); + } + + #[test_only] + public fun init_register_and_mint( + scenario: &mut Scenario, + caller: address, + amount: u64 + ): Balance { + // First publish and register. + init_and_register(scenario, caller); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Mint. + balance::create_for_testing(amount) + } + + #[test_only] + public fun init_register_and_deposit( + scenario: &mut Scenario, + caller: address, + amount: u64 + ) { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + + let minted = init_register_and_mint(scenario, caller, amount); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + native_asset::deposit_test_only( + token_registry::borrow_mut_native_test_only( + state::borrow_mut_token_registry_test_only( + &mut token_bridge_state + ) + ), + minted + ); + + return_state(token_bridge_state); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_NATIVE_4 {}, ctx); + } + + public fun take_metadata( + scenario: &Scenario + ): CoinMetadata { + test_scenario::take_shared(scenario) + } + + public fun return_metadata( + metadata: CoinMetadata + ) { + test_scenario::return_shared(metadata); + } + + public fun take_treasury_cap( + scenario: &Scenario + ): TreasuryCap { + test_scenario::take_shared(scenario) + } + + public fun return_treasury_cap( + treasury_cap: TreasuryCap + ) { + test_scenario::return_shared(treasury_cap); + } + + public fun take_globals( + scenario: &Scenario + ): ( + TreasuryCap, + CoinMetadata + ) { + ( + take_treasury_cap(scenario), + take_metadata(scenario) + ) + } + + public fun return_globals( + treasury_cap: TreasuryCap, + metadata: CoinMetadata + ) { + return_treasury_cap(treasury_cap); + return_metadata(metadata); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/coin_wrapped_12.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/coin_wrapped_12.move new file mode 100644 index 0000000000..74932765ef --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/coin_wrapped_12.move @@ -0,0 +1,193 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +module token_bridge::coin_wrapped_12 { + use sui::balance::{Balance}; + use sui::package::{UpgradeCap}; + use sui::coin::{CoinMetadata, TreasuryCap}; + use sui::test_scenario::{Self, Scenario}; + use sui::transfer::{Self}; + use sui::tx_context::{Self, TxContext}; + + use token_bridge::asset_meta::{Self, AssetMeta}; + use token_bridge::create_wrapped::{Self, WrappedAssetSetup}; + use token_bridge::state::{Self}; + use token_bridge::token_registry::{Self}; + use token_bridge::wrapped_asset::{Self}; + + use token_bridge::version_control::{V__0_2_0 as V__CURRENT}; + + struct COIN_WRAPPED_12 has drop {} + + const VAA: vector = + x"0100000000010080366065746148420220f25a6275097370e8db40984529a6676b7a5fc9feb11755ec49ca626b858ddfde88d15601f85ab7683c5f161413b0412143241c700aff010000000100000001000200000000000000000000000000000000000000000000000000000000deadbeef000000000150eb23000200000000000000000000000000000000000000000000000000000000beefface00020c424545460000000000000000000000000000000000000000000000000000000042656566206661636520546f6b656e0000000000000000000000000000000000"; + + const UPDATED_VAA: vector = + x"0100000000010062f4dcd21bbbc4af8b8baaa2da3a0b168efc4c975de5b828c7a3c710b67a0a0d476d10a74aba7a7867866daf97d1372d8e6ee62ccc5ae522e3e603c67fa23787000000000000000045000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f0200000000000000000000000000000000000000000000000000000000beefface00020c424545463f3f3f20616e642070726f666974000000000000000000000000000042656566206661636520546f6b656e3f3f3f20616e642070726f666974000000"; + + fun init(witness: COIN_WRAPPED_12, ctx: &mut TxContext) { + let ( + setup, + upgrade_cap + ) = + create_wrapped::new_setup_current( + witness, + 8, // capped to 8 + ctx + ); + transfer::public_transfer(setup, tx_context::sender(ctx)); + transfer::public_transfer(upgrade_cap, tx_context::sender(ctx)); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_WRAPPED_12 {}, ctx); + } + + + public fun encoded_vaa(): vector { + VAA + } + + public fun encoded_updated_vaa(): vector { + UPDATED_VAA + } + + #[allow(implicit_const_copy)] + public fun token_meta(): AssetMeta { + asset_meta::deserialize_test_only( + wormhole::vaa::peel_payload_from_vaa(&VAA) + ) + } + + #[allow(implicit_const_copy)] + public fun updated_token_meta(): AssetMeta { + asset_meta::deserialize_test_only( + wormhole::vaa::peel_payload_from_vaa(&UPDATED_VAA) + ) + } + + #[test_only] + /// for a test scenario, simply deploy the coin and expose `Supply`. + public fun init_and_take_treasury_cap( + scenario: &mut Scenario, + caller: address + ): TreasuryCap { + use token_bridge::create_wrapped; + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Publish coin. + init(COIN_WRAPPED_12 {}, test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + create_wrapped::take_treasury_cap( + test_scenario::take_from_sender(scenario) + ) + } + + #[test_only] + /// For a test scenario, register this wrapped asset. + /// + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_and_register( + scenario: &mut Scenario, + caller: address + ) { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Publish coin. + init(COIN_WRAPPED_12 {}, test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + let msg = + token_bridge::vaa::verify_only_once( + &mut token_bridge_state, + verified_vaa + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let coin_meta = + test_scenario::take_shared>(scenario); + + // Register the attested asset. + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + test_scenario::take_from_sender< + WrappedAssetSetup + >( + scenario + ), + test_scenario::take_from_sender(scenario), + msg + ); + + test_scenario::return_shared(coin_meta); + + // Clean up. + return_state(token_bridge_state); + } + + #[test_only] + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_register_and_mint( + scenario: &mut Scenario, + caller: address, + amount: u64 + ): Balance { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + + // First publish and register. + init_and_register(scenario, caller); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + let minted = + wrapped_asset::mint_test_only( + token_registry::borrow_mut_wrapped_test_only( + state::borrow_mut_token_registry_test_only( + &mut token_bridge_state + ) + ), + amount + ); + + return_state(token_bridge_state); + + minted + } +} + +#[test_only] +module token_bridge::coin_wrapped_12_tests { + use token_bridge::asset_meta::{Self}; + use token_bridge::coin_wrapped_12::{token_meta}; + + #[test] + fun test_native_decimals() { + let meta = token_meta(); + assert!(asset_meta::native_decimals(&meta) == 12, 0); + asset_meta::destroy(meta); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/coin_wrapped_7.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/coin_wrapped_7.move new file mode 100644 index 0000000000..fa09e1b444 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/coin_wrapped_7.move @@ -0,0 +1,194 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +module token_bridge::coin_wrapped_7 { + use sui::balance::{Balance}; + use sui::coin::{CoinMetadata, TreasuryCap}; + use sui::package::{UpgradeCap}; + use sui::test_scenario::{Self, Scenario}; + use sui::transfer::{Self}; + use sui::tx_context::{Self, TxContext}; + + use token_bridge::asset_meta::{Self, AssetMeta}; + use token_bridge::create_wrapped::{Self, WrappedAssetSetup}; + use token_bridge::state::{Self}; + use token_bridge::token_registry::{Self}; + use token_bridge::wrapped_asset::{Self}; + + use token_bridge::version_control::{V__0_2_0 as V__CURRENT}; + + struct COIN_WRAPPED_7 has drop {} + + // TODO: need to fix the emitter address + // +------------------------------------------------------------------------------+ + // | Wormhole VAA v1 | nonce: 69 | time: 0 | + // | guardian set #0 | #1 | consistency: 15 | + // |------------------------------------------------------------------------------| + // | Signature: | + // | #0: 3d8fd671611d84801dc9d14a07835e8729d217b1aac77b054175d0f91294... | + // |------------------------------------------------------------------------------| + // | Emitter: 0x00000000000000000000000000000000deadbeef (Ethereum) | + // |------------------------------------------------------------------------------| + // | Token attestation | + // | decimals: 7 | + // | Token: 0x00000000000000000000000000000000deafface (Ethereum) | + // | Symbol: DEC7 | + // | Name: DECIMALS 7 | + // +------------------------------------------------------------------------------+ + const VAA: vector = + x"010000000001003d8fd671611d84801dc9d14a07835e8729d217b1aac77b054175d0f91294040742a1ed6f3e732b2fbf208e64422816accf89dd0cd3ead20d2e0fb3d372ce221c010000000000000045000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f0200000000000000000000000000000000000000000000000000000000deafface000207000000000000000000000000000000000000000000000000000000004445433700000000000000000000000000000000000000000000444543494d414c532037"; + + fun init(witness: COIN_WRAPPED_7, ctx: &mut TxContext) { + let ( + setup, + upgrade_cap + ) = + create_wrapped::new_setup_current( + witness, + 7, + ctx + ); + transfer::public_transfer(setup, tx_context::sender(ctx)); + transfer::public_transfer(upgrade_cap, tx_context::sender(ctx)); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_WRAPPED_7 {}, ctx); + } + + public fun encoded_vaa(): vector { + VAA + } + + #[allow(implicit_const_copy)] + public fun token_meta(): AssetMeta { + asset_meta::deserialize_test_only( + wormhole::vaa::peel_payload_from_vaa(&VAA) + ) + } + + #[test_only] + /// for a test scenario, simply deploy the coin and expose `TreasuryCap`. + public fun init_and_take_treasury_cap( + scenario: &mut Scenario, + caller: address + ): TreasuryCap { + use token_bridge::create_wrapped; + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Publish coin. + init(COIN_WRAPPED_7 {}, test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + create_wrapped::take_treasury_cap( + test_scenario::take_from_sender(scenario) + ) + } + + #[test_only] + /// For a test scenario, register this wrapped asset. + /// + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_and_register( + scenario: &mut Scenario, + caller: address + ) { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Publish coin. + init(COIN_WRAPPED_7 {}, test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + let msg = + token_bridge::vaa::verify_only_once( + &mut token_bridge_state, + verified_vaa + ); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let coin_meta = + test_scenario::take_shared>(scenario); + + // Register the attested asset. + create_wrapped::complete_registration( + &mut token_bridge_state, + &mut coin_meta, + test_scenario::take_from_sender< + WrappedAssetSetup + >( + scenario + ), + test_scenario::take_from_sender(scenario), + msg + ); + + test_scenario::return_shared(coin_meta); + + // Clean up. + return_state(token_bridge_state); + } + + #[test_only] + /// NOTE: Even though this module is `#[test_only]`, this method is tagged + /// with the same macro as a trick to allow another method within this + /// module to call `init` using OTW. + public fun init_register_and_mint( + scenario: &mut Scenario, + caller: address, + amount: u64 + ): Balance { + use token_bridge::token_bridge_scenario::{return_state, take_state}; + + // First publish and register. + init_and_register(scenario, caller); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + let minted = + wrapped_asset::mint_test_only( + token_registry::borrow_mut_wrapped_test_only( + state::borrow_mut_token_registry_test_only( + &mut token_bridge_state + ) + ), + amount + ); + + return_state(token_bridge_state); + + minted + } +} + +#[test_only] +module token_bridge::coin_wrapped_7_tests { + use token_bridge::asset_meta::{Self}; + use token_bridge::coin_wrapped_7::{token_meta}; + + #[test] + fun test_native_decimals() { + let meta = token_meta(); + assert!(asset_meta::native_decimals(&meta) == 7, 0); + asset_meta::destroy(meta); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/dummy_message.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/dummy_message.move new file mode 100644 index 0000000000..d3784e5a97 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/dummy_message.move @@ -0,0 +1,146 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +module token_bridge::dummy_message { + public fun encoded_transfer(): vector { + // let decimals = 8; + // let expected_amount = normalized_amount::from_raw(234567890, decimals); + // let expected_token_address = external_address::from_address(@0xbeef); + // let expected_token_chain = 1; + // let expected_recipient = external_address::from_address(@0xcafe); + // let expected_recipient_chain = 7; + // let expected_relayer_fee = + // normalized_amount::from_raw(123456789, decimals); + x"01000000000000000000000000000000000000000000000000000000000dfb38d2000000000000000000000000000000000000000000000000000000000000beef0001000000000000000000000000000000000000000000000000000000000000cafe000700000000000000000000000000000000000000000000000000000000075bcd15" + } + + public fun encoded_transfer_with_payload(): vector { + // let expected_amount = normalized_amount::from_raw(234567890, 8); + // let expected_token_address = external_address::from_address(@0xbeef); + // let expected_token_chain = 1; + // let expected_recipient = external_address::from_address(@0xcafe); + // let expected_recipient_chain = 7; + // let expected_sender = external_address::from_address(@0xdeadbeef); + // let expected_payload = b"All your base are belong to us."; + x"03000000000000000000000000000000000000000000000000000000000dfb38d2000000000000000000000000000000000000000000000000000000000000beef0001000000000000000000000000000000000000000000000000000000000000cafe0007381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f409416c6c20796f75722062617365206172652062656c6f6e6720746f2075732e" + } + + public fun encoded_transfer_vaa_native_with_fee(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x0000000000000000000000000000000000000000000000000000000000000001', + // tokenChain: 21, + // toAddress: '0x000000000000000000000000000000000000000000000000000000000000b0b1', + // chain: 21, + // fee: 1000n + x"01000000000100bce07d9dce4e16f564788b0885fa31fa6c5c1bb7ee1f7d0948b8f2c2ae9e87ea4eccfc86affb8b7cf8bfcc774effe0fa7a54066d8a4310a4bb0350fd3097ab25000000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f010000000000000000000000000000000000000000000000000000000000000bb80bc9c77af025eb7f73940ad00c9d6f06d45253339a110b0f9ff03b822e5877d30015000000000000000000000000000000000000000000000000000000000000b0b1001500000000000000000000000000000000000000000000000000000000000003e8" + } + + public fun encoded_transfer_with_payload_vaa_native(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x0000000000000000000000000000000000000000000000000000000000000001', + // tokenChain: 21, + // toAddress: '0x381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f409', + // chain: 21, + // fromAddress: '0x000000000000000000000000000000000000000000000000000000000badc0de', + // payload: 'All your base are belong to us.' + x"010000000001003aced6a481653aa534b2f679122e0179de056dbef47442b8c3a1a810dbdfa71049f53cab6e82362800c1558d44993fa6e958a75bd6e6a3472dd278e900041e29010000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f030000000000000000000000000000000000000000000000000000000000000bb80bc9c77af025eb7f73940ad00c9d6f06d45253339a110b0f9ff03b822e5877d30015381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f4090015000000000000000000000000000000000000000000000000000000000badc0de416c6c20796f75722062617365206172652062656c6f6e6720746f2075732e" + } + + public fun encoded_transfer_vaa_wrapped_12_with_fee(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000beefface', + // tokenChain: 2, + // toAddress: '0x000000000000000000000000000000000000000000000000000000000000b0b1', + // chain: 21, + // fee: 1000n + x"010000000001005537ca9a981a62823f57a706f3ceab648391fd99a11631296f798aa394ba6aff73540afefad8634ed573c73c5aa9a16e68906321fa6a4c8a488611b933b1f5b1000000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f010000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000beefface0002000000000000000000000000000000000000000000000000000000000000b0b1001500000000000000000000000000000000000000000000000000000000000003e8" + } + + public fun encoded_transfer_vaa_wrapped_12_without_fee(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000beefface', + // tokenChain: 2, + // toAddress: '0x000000000000000000000000000000000000000000000000000000000000b0b1', + // chain: 21, + // fee: 0n + x"01000000000100e5558a2955f94fdb174d7868c9f643700174949ac72b90f803bdbea00453ed4c426c055b956060c905189cb710b97916af6a77cd3168f83eca9c66b6366c85c4000000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f010000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000beefface0002000000000000000000000000000000000000000000000000000000000000b0b100150000000000000000000000000000000000000000000000000000000000000000" + } + + public fun encoded_transfer_with_payload_wrapped_12(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000beefface', + // tokenChain: 2, + // toAddress: '0x381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f409', + // chain: 21, + // fromAddress: '0x000000000000000000000000000000000000000000000000000000000badc0de', + // payload: 'All your base are belong to us.' + x"0100000000010054968c9be4059d7dc373fff8e80dfc9083c485663517534807d61d11abec64896c4185a2bdd71e3caa713d082c78f5d8b1586c56bd5042dfaba1de0ca0d978a0010000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f030000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000beefface0002381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f4090015000000000000000000000000000000000000000000000000000000000badc0de416c6c20796f75722062617365206172652062656c6f6e6720746f2075732e" + } + + public fun encoded_transfer_vaa_wrapped_7_with_fee(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000deafface', + // tokenChain: 2, + // toAddress: '0x000000000000000000000000000000000000000000000000000000000000b0b1', + // chain: 21, + // fee: 1000n + x"01000000000100b9dc34e110e4268ac1e0ef729513083d45b59e0c2cbee8f9fd7d7d2ed900c8ad2a5ca55310fb3741bf3ff8c611e37a2fee2852e09feb491261edf53fcc956edf010000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f010000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000deafface0002000000000000000000000000000000000000000000000000000000000000b0b1001500000000000000000000000000000000000000000000000000000000000003e8" + } + + public fun encoded_transfer_vaa_wrapped_7_without_fee(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000deafface', + // tokenChain: 2, + // toAddress: '0x000000000000000000000000000000000000000000000000000000000000b0b1', + // chain: 21, + // fee: 0n + x"01000000000100389f0544dc2d3f7095d4e9543ae9f6cb5c9dd6a561e95ed896c870907fe85a94373a455acac8d2ad66154df1cb19ba4ae6c583a1c2839971e6760ecaa1d9fca7000000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f010000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000deafface0002000000000000000000000000000000000000000000000000000000000000b0b100150000000000000000000000000000000000000000000000000000000000000000" + } + + public fun encoded_transfer_vaa_wrapped_12_invalid_target_chain(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000beefface', + // tokenChain: 2, + // toAddress: '0x000000000000000000000000000000000000000000000000000000000000b0b1', + // chain: 69, + // fee: 0n + x"010000000001009c0b89b21622bde003f8e775daffe343e65d6a537719bc977c85b0b18c26751c7bff61077e74711dfe865d935fa840a7352d7a1ccbcec4be77bfc591cd265a48000000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f010000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000beefface0002000000000000000000000000000000000000000000000000000000000000b0b1004500000000000000000000000000000000000000000000000000000000000003e8" + } + + public fun encoded_transfer_with_payload_wrapped_12_invalid_target_chain(): vector { + // emitterChain: 2, + // emitterAddress: '0x00000000000000000000000000000000000000000000000000000000deadbeef', + // amount: 3000n, + // tokenAddress: '0x00000000000000000000000000000000000000000000000000000000beefface', + // tokenChain: 2, + // toAddress: '0x381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f409', + // chain: 21, + // fromAddress: '0x000000000000000000000000000000000000000000000000000000000badc0de', + // payload: 'All your base are belong to us.' + x"01000000000100b139a7dbb747b04509ae4f511080a9cb080e423d8db086d5c7553baed2d6151e3fbdd00e691d82662b8d1ed49ec374dba5f82e82df20921151da4b948ddce41e000000000000000000000200000000000000000000000000000000000000000000000000000000deadbeef00000000000000010f030000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000beefface0002381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f4090045000000000000000000000000000000000000000000000000000000000badc0de416c6c20796f75722062617365206172652062656c6f6e6720746f2075732e" + } + + public fun encoded_register_chain_2(): vector { + x"0100000000010015d405c74be6d93c3c33ed6b48d8db70dfb31e0981f8098b2a6c7583083e0c3343d4a1abeb3fc1559674fa067b0c0e2e9de2fafeaecdfeae132de2c33c9d27cc0100000001000000010001000000000000000000000000000000000000000000000000000000000000000400000000016911ae00000000000000000000000000000000000000000000546f6b656e427269646765010000000200000000000000000000000000000000000000000000000000000000deadbeef" + } + + public fun encoded_asset_meta_vaa_foreign_12(): vector { + x"0100000000010080366065746148420220f25a6275097370e8db40984529a6676b7a5fc9feb11755ec49ca626b858ddfde88d15601f85ab7683c5f161413b0412143241c700aff010000000100000001000200000000000000000000000000000000000000000000000000000000deadbeef000000000150eb23000200000000000000000000000000000000000000000000000000000000beefface00020c424545460000000000000000000000000000000000000000000000000000000042656566206661636520546f6b656e0000000000000000000000000000000000" + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/token_bridge_scenario.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/token_bridge_scenario.move new file mode 100644 index 0000000000..d7921ee809 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/test/token_bridge_scenario.move @@ -0,0 +1,136 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +module token_bridge::token_bridge_scenario { + use std::vector::{Self}; + use sui::balance::{Self}; + use sui::package::{UpgradeCap}; + use sui::test_scenario::{Self, Scenario}; + use wormhole::external_address::{Self}; + use wormhole::wormhole_scenario::{ + deployer, + return_state as return_wormhole_state, + set_up_wormhole, + take_state as take_wormhole_state + }; + + use token_bridge::native_asset::{Self}; + use token_bridge::setup::{Self, DeployerCap}; + use token_bridge::state::{Self, State}; + use token_bridge::token_registry::{Self}; + + public fun set_up_wormhole_and_token_bridge( + scenario: &mut Scenario, + wormhole_fee: u64 + ) { + // init and share wormhole core bridge + set_up_wormhole(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, deployer()); + + // Publish Token Bridge. + setup::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, deployer()); + + let wormhole_state = take_wormhole_state(scenario); + + let upgrade_cap = + test_scenario::take_from_sender(scenario); + let emitter_cap = + wormhole::emitter::new( + &wormhole_state, + test_scenario::ctx(scenario) + ); + let governance_chain = 1; + let governance_contract = + x"0000000000000000000000000000000000000000000000000000000000000004"; + + // Finally share `State`. + setup::complete( + test_scenario::take_from_sender(scenario), + upgrade_cap, + emitter_cap, + governance_chain, + governance_contract, + test_scenario::ctx(scenario) + ); + + // Clean up. + return_wormhole_state(wormhole_state); + } + + /// Perform an upgrade (which just upticks the current version of what the + /// `State` believes is true). + public fun upgrade_token_bridge(scenario: &mut Scenario) { + // Clean up from activity prior. + test_scenario::next_tx(scenario, person()); + + let token_bridge_state = take_state(scenario); + state::test_upgrade(&mut token_bridge_state); + + // Clean up. + return_state(token_bridge_state); + } + + /// Register arbitrary chain ID with the same emitter address (0xdeadbeef). + public fun register_dummy_emitter(scenario: &mut Scenario, chain: u16) { + // Ignore effects. + test_scenario::next_tx(scenario, person()); + + let token_bridge_state = take_state(scenario); + token_bridge::register_chain::register_new_emitter_test_only( + &mut token_bridge_state, + chain, + external_address::from_address(@0xdeadbeef) + ); + + // Clean up. + return_state(token_bridge_state); + } + + /// Register 0xdeadbeef for multiple chains. + public fun register_dummy_emitters( + scenario: &mut Scenario, + chains: vector + ) { + while (!vector::is_empty(&chains)) { + register_dummy_emitter(scenario, vector::pop_back(&mut chains)); + }; + vector::destroy_empty(chains); + } + + public fun deposit_native( + token_bridge_state: &mut State, + deposit_amount: u64 + ) { + native_asset::deposit_test_only( + token_registry::borrow_mut_native_test_only( + state::borrow_mut_token_registry_test_only(token_bridge_state) + ), + balance::create_for_testing(deposit_amount) + ) + } + + public fun person(): address { + wormhole::wormhole_scenario::person() + } + + public fun two_people(): (address, address) { + wormhole::wormhole_scenario::two_people() + } + + public fun three_people(): (address, address, address) { + wormhole::wormhole_scenario::three_people() + } + + public fun take_state(scenario: &Scenario): State { + test_scenario::take_shared(scenario) + } + + public fun return_state(token_bridge_state: State) { + test_scenario::return_shared(token_bridge_state); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/transfer_tokens.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/transfer_tokens.move new file mode 100644 index 0000000000..60f1aa2301 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/transfer_tokens.move @@ -0,0 +1,1053 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements three methods: `prepare_transfer` and +/// `transfer_tokens`, which are meant to work together. +/// +/// `prepare_transfer` allows a contract to pack token transfer parameters in +/// preparation to bridge these assets to another network. Anyone can call this +/// method to create `TransferTicket`. +/// +/// `transfer_tokens` unpacks the `TransferTicket` and constructs a +/// `MessageTicket`, which will be used by Wormhole's `publish_message` +/// module. +/// +/// The purpose of splitting this token transferring into two steps is in case +/// Token Bridge needs to be upgraded and there is a breaking change for this +/// module, an integrator would not be left broken. It is discouraged to put +/// `transfer_tokens` in an integrator's package logic. Otherwise, this +/// integrator needs to be prepared to upgrade his contract to handle the latest +/// version of `transfer_tokens`. +/// +/// Instead, an integrator is encouraged to execute a transaction block, which +/// executes `transfer_tokens` using the latest Token Bridge package ID and to +/// implement `prepare_transfer` in his contract to produce `PrepareTransfer`. +/// +/// NOTE: Only assets that exist in the `TokenRegistry` can be bridged out, +/// which are native Sui assets that have been attested for via `attest_token` +/// and wrapped foreign assets that have been created using foreign asset +/// metadata via the `create_wrapped` module. +/// +/// See `transfer` module for serialization and deserialization of Wormhole +/// message payload. +module token_bridge::transfer_tokens { + use sui::balance::{Self, Balance}; + use sui::coin::{Self, Coin}; + use wormhole::bytes32::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + use wormhole::publish_message::{MessageTicket}; + + use token_bridge::native_asset::{Self}; + use token_bridge::normalized_amount::{Self, NormalizedAmount}; + use token_bridge::state::{Self, State, LatestOnly}; + use token_bridge::token_registry::{Self, VerifiedAsset}; + use token_bridge::transfer::{Self}; + use token_bridge::wrapped_asset::{Self}; + + friend token_bridge::transfer_tokens_with_payload; + + /// Relayer fee exceeds `Coin` object's value. + const E_RELAYER_FEE_EXCEEDS_AMOUNT: u64 = 0; + + /// This type represents transfer data for a recipient on a foreign chain. + /// The only way to destroy this type is calling `transfer_tokens`. + /// + /// NOTE: An integrator that expects to bridge assets between his contracts + /// should probably use the `transfer_tokens_with_payload` module, which + /// expects a specific redeemer to complete the transfer (transfers sent + /// using `transfer_tokens` can be redeemed by anyone on behalf of the + /// encoded recipient). + struct TransferTicket { + asset_info: VerifiedAsset, + bridged_in: Balance, + norm_amount: NormalizedAmount, + recipient_chain: u16, + recipient: vector, + relayer_fee: u64, + nonce: u32 + } + + /// `prepare_transfer` constructs token transfer parameters. Any remaining + /// amount (A.K.A. dust) from the funds provided will be returned along with + /// the `TransferTicket` type. The returned coin object is the same object + /// moved into this method. + /// + /// NOTE: Integrators of Token Bridge should be calling only this method + /// from their contracts. This method is not guarded by version control + /// (thus not requiring a reference to the Token Bridge `State` object), so + /// it is intended to work for any package version. + public fun prepare_transfer( + asset_info: VerifiedAsset, + funded: Coin, + recipient_chain: u16, + recipient: vector, + relayer_fee: u64, + nonce: u32 + ): ( + TransferTicket, + Coin + ) { + let ( + bridged_in, + norm_amount + ) = take_truncated_amount(&asset_info, &mut funded); + + let ticket = + TransferTicket { + asset_info, + bridged_in, + norm_amount, + relayer_fee, + recipient_chain, + recipient, + nonce + }; + + // The remaining amount of funded may have dust depending on the + // decimals of this asset. + (ticket, funded) + } + + /// `transfer_tokens` is the only method that can unpack the members of + /// `TransferTicket`. This method takes the balance from this type and + /// bridges this asset out of Sui by either joining its balance in the Token + /// Bridge's custody for native assets or burning its balance for wrapped + /// assets. + /// + /// A `relayer_fee` of some value less than or equal to the bridged balance + /// can be specified to incentivize someone to redeem this transfer on + /// behalf of the `recipient`. + /// + /// This method returns the prepared Wormhole message (which should be + /// consumed by calling `publish_message` in a transaction block). + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + /// + /// It is important for integrators to refrain from calling this method + /// within their contracts. This method is meant to be called in a + /// transaction block after receiving a `TransferTicket` from calling + /// `prepare_transfer` within a contract. If in a circumstance where this + /// module has a breaking change in an upgrade, `prepare_transfer` will not + /// be affected by this change. + public fun transfer_tokens( + token_bridge_state: &mut State, + ticket: TransferTicket + ): MessageTicket { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + let ( + nonce, + encoded_transfer + ) = + bridge_in_and_serialize_transfer( + &latest_only, + token_bridge_state, + ticket + ); + + // Prepare Wormhole message with encoded `Transfer`. + state::prepare_wormhole_message( + &latest_only, + token_bridge_state, + nonce, + encoded_transfer + ) + } + + /// Modify coin based on the decimals of a given coin type, which may + /// leave some amount if the decimals lead to truncating the coin's balance. + /// This method returns the extracted balance (which will be bridged out of + /// Sui) and the normalized amount, which will be encoded in the token + /// transfer payload. + /// + /// NOTE: This is a privileged method, which only this and the + /// `transfer_tokens_with_payload` modules can use. + public(friend) fun take_truncated_amount( + asset_info: &VerifiedAsset, + funded: &mut Coin + ): ( + Balance, + NormalizedAmount + ) { + // Calculate dust. If there is any, `bridged_in` will have remaining + // value after split. `norm_amount` is copied since it is denormalized + // at this step. + let decimals = token_registry::coin_decimals(asset_info); + let norm_amount = + normalized_amount::from_raw(coin::value(funded), decimals); + + // Split the `bridged_in` coin object to return any dust remaining on + // that object. Only bridge in the adjusted amount after de-normalizing + // the normalized amount. + let truncated = + balance::split( + coin::balance_mut(funded), + normalized_amount::to_raw(norm_amount, decimals) + ); + + (truncated, norm_amount) + } + + /// For a given coin type, either burn Token Bridge wrapped assets or + /// deposit coin into Token Bridge's custody. This method returns the + /// canonical token info (chain ID and address), which will be encoded in + /// the token transfer. + /// + /// NOTE: This is a privileged method, which only this and the + /// `transfer_tokens_with_payload` modules can use. + public(friend) fun burn_or_deposit_funds( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + asset_info: &VerifiedAsset, + bridged_in: Balance + ): ( + u16, + ExternalAddress + ) { + // Either burn or deposit depending on `CoinType`. + let registry = + state::borrow_mut_token_registry(latest_only, token_bridge_state); + if (token_registry::is_wrapped(asset_info)) { + wrapped_asset::burn( + token_registry::borrow_mut_wrapped(registry), + bridged_in + ); + } else { + native_asset::deposit( + token_registry::borrow_mut_native(registry), + bridged_in + ); + }; + + // Return canonical token info. + ( + token_registry::token_chain(asset_info), + token_registry::token_address(asset_info) + ) + } + + fun bridge_in_and_serialize_transfer( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + ticket: TransferTicket + ): ( + u32, + vector + ) { + let TransferTicket { + asset_info, + bridged_in, + norm_amount, + recipient_chain, + recipient, + relayer_fee, + nonce + } = ticket; + + // Disallow `relayer_fee` to be greater than the `Coin` object's value. + // Keep in mind that the relayer fee is evaluated against the truncated + // amount. + let amount = sui::balance::value(&bridged_in); + assert!(relayer_fee <= amount, E_RELAYER_FEE_EXCEEDS_AMOUNT); + + // Handle funds and get canonical token info for encoded transfer. + let ( + token_chain, + token_address + ) = burn_or_deposit_funds( + latest_only, + token_bridge_state, + &asset_info, bridged_in + ); + + // Ensure that the recipient is a 32-byte address. + let recipient = external_address::new(bytes32::from_bytes(recipient)); + + // Finally encode `Transfer`. + let encoded = + transfer::serialize( + transfer::new( + norm_amount, + token_address, + token_chain, + recipient, + recipient_chain, + normalized_amount::from_raw( + relayer_fee, + token_registry::coin_decimals(&asset_info) + ) + ) + ); + + (nonce, encoded) + } + + #[test_only] + public fun bridge_in_and_serialize_transfer_test_only( + token_bridge_state: &mut State, + ticket: TransferTicket + ): ( + u32, + vector + ) { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + bridge_in_and_serialize_transfer( + &latest_only, + token_bridge_state, + ticket + ) + } +} + +#[test_only] +module token_bridge::transfer_token_tests { + use sui::coin::{Self}; + use sui::test_scenario::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::external_address::{Self}; + use wormhole::publish_message::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::coin_wrapped_7::{Self, COIN_WRAPPED_7}; + use token_bridge::native_asset::{Self}; + use token_bridge::normalized_amount::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + set_up_wormhole_and_token_bridge, + register_dummy_emitter, + return_state, + take_state, + person + }; + use token_bridge::token_registry::{Self}; + use token_bridge::transfer::{Self}; + use token_bridge::transfer_tokens::{Self}; + use token_bridge::wrapped_asset::{Self}; + + /// Test consts. + const TEST_TARGET_RECIPIENT: vector = x"beef4269"; + const TEST_TARGET_CHAIN: u16 = 2; + const TEST_NONCE: u32 = 0; + const TEST_COIN_NATIVE_10_DECIMALS: u8 = 10; + const TEST_COIN_WRAPPED_7_DECIMALS: u8 = 7; + + #[test] + fun test_transfer_tokens_native_10() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let coin_10_balance = + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 100000; + + // Balance check the Token Bridge before executing the transfer. The + // initial balance should be zero for COIN_NATIVE_10. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == 0, 0); + }; + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Call `transfer_tokens`. + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Balance check the Token Bridge after executing the transfer. The + // balance should now reflect the `transfer_amount` defined in this + // test. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == transfer_amount, 0); + }; + + // Clean up. + publish_message::destroy(prepared_msg); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_transfer_tokens_native_10_with_dust_refund() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 1000069; + let coin_10_balance = + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // This value will be used later. The contract should return dust + // to the caller since COIN_NATIVE_10 has 10 decimals. + let expected_dust = 69; + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 100000; + + // Balance check the Token Bridge before executing the transfer. The + // initial balance should be zero for COIN_NATIVE_10. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == 0, 0); + }; + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + assert!(coin::value(&dust) == expected_dust, 0); + + // Call `transfer_tokens`. + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Balance check the Token Bridge after executing the transfer. The + // balance should now reflect the `transfer_amount` less `expected_dust` + // defined in this test. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!( + native_asset::custody(asset) == transfer_amount - expected_dust, + 0 + ); + }; + + // Clean up. + publish_message::destroy(prepared_msg); + coin::burn_for_testing(dust); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_serialize_transfer_tokens_native_10() { + use token_bridge::transfer_tokens::{ + bridge_in_and_serialize_transfer_test_only, + prepare_transfer + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let bridged_coin_10 = + coin::from_balance( + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ), + test_scenario::ctx(scenario) + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 100000; + + let asset_info = state::verified_asset(&token_bridge_state); + let expected_token_address = token_registry::token_address(&asset_info); + + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + bridged_coin_10, + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Call `transfer_tokens`. + let ( + nonce, + payload + ) = + bridge_in_and_serialize_transfer_test_only( + &mut token_bridge_state, + ticket + ); + assert!(nonce == TEST_NONCE, 0); + + // Construct expected payload from scratch and confirm that the + // `transfer_tokens` call produces the same payload. + let expected_amount = + normalized_amount::from_raw( + transfer_amount, + TEST_COIN_NATIVE_10_DECIMALS + ); + let expected_relayer_fee = + normalized_amount::from_raw( + relayer_fee, + TEST_COIN_NATIVE_10_DECIMALS + ); + + let expected_payload = + transfer::new_test_only( + expected_amount, + expected_token_address, + chain_id(), + external_address::new( + bytes32::from_bytes(TEST_TARGET_RECIPIENT) + ), + TEST_TARGET_CHAIN, + expected_relayer_fee + ); + assert!(transfer::serialize_test_only(expected_payload) == payload, 0); + + // Clean up. + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_transfer_tokens_wrapped_7() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 42069000; + let coin_7_balance = + coin_wrapped_7::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 100000; + + // Balance check the Token Bridge before executing the transfer. The + // initial balance should be the `transfer_amount` for COIN_WRAPPED_7. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = + token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == transfer_amount, 0); + }; + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + coin::from_balance( + coin_7_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Call `transfer_tokens`. + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Balance check the Token Bridge after executing the transfer. The + // balance should be zero, since tokens are burned when an outbound + // wrapped token transfer occurs. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == 0, 0); + }; + + // Clean up. + publish_message::destroy(prepared_msg); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_serialize_transfer_tokens_wrapped_7() { + use token_bridge::transfer_tokens::{ + bridge_in_and_serialize_transfer_test_only, + prepare_transfer + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let bridged_coin_7 = + coin::from_balance( + coin_wrapped_7::init_register_and_mint( + scenario, + sender, + transfer_amount + ), + test_scenario::ctx(scenario) + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 100000; + + let asset_info = state::verified_asset(&token_bridge_state); + let expected_token_address = token_registry::token_address(&asset_info); + let expected_token_chain = token_registry::token_chain(&asset_info); + + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + bridged_coin_7, + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Call `transfer_tokens`. + let ( + nonce, + payload + ) = + bridge_in_and_serialize_transfer_test_only( + &mut token_bridge_state, + ticket + ); + assert!(nonce == TEST_NONCE, 0); + + // Construct expected payload from scratch and confirm that the + // `transfer_tokens` call produces the same payload. + let expected_amount = + normalized_amount::from_raw( + transfer_amount, + TEST_COIN_WRAPPED_7_DECIMALS + ); + let expected_relayer_fee = + normalized_amount::from_raw( + relayer_fee, + TEST_COIN_WRAPPED_7_DECIMALS + ); + + let expected_payload = + transfer::new_test_only( + expected_amount, + expected_token_address, + expected_token_chain, + external_address::new( + bytes32::from_bytes(TEST_TARGET_RECIPIENT) + ), + TEST_TARGET_CHAIN, + expected_relayer_fee + ); + assert!(transfer::serialize_test_only(expected_payload) == payload, 0); + + // Clean up. + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = token_registry::E_UNREGISTERED)] + fun test_cannot_transfer_tokens_native_not_registered() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Initialize COIN_NATIVE_10 (but don't register it). + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + // NOTE: This test purposely doesn't `attest` COIN_NATIVE_10. + let transfer_amount = 6942000; + let test_coins = + coin::mint_for_testing( + transfer_amount, + test_scenario::ctx(scenario) + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 100000; + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + test_coins, + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // You shall not pass! + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Clean up. + publish_message::destroy(prepared_msg); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = token_registry::E_UNREGISTERED)] + fun test_cannot_transfer_tokens_wrapped_not_registered() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Initialize COIN_WRAPPED_7 (but don't register it). + coin_native_10::init_test_only(test_scenario::ctx(scenario)); + + let treasury_cap = + coin_wrapped_7::init_and_take_treasury_cap( + scenario, + sender + ); + sui::test_utils::destroy(treasury_cap); + + // NOTE: This test purposely doesn't `attest` COIN_WRAPPED_7. + let transfer_amount = 42069; + let test_coins = + coin::mint_for_testing( + transfer_amount, + test_scenario::ctx(scenario) + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Define the relayer fee. + let relayer_fee = 1000; + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + test_coins, + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // You shall not pass! + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Clean up. + publish_message::destroy(prepared_msg); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = transfer_tokens::E_RELAYER_FEE_EXCEEDS_AMOUNT + )] + fun test_cannot_transfer_tokens_fee_exceeds_amount() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // NOTE: The `relayer_fee` is intentionally set to a higher number + // than the `transfer_amount`. + let relayer_fee = 100001; + let transfer_amount = 100000; + let coin_10_balance = + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // You shall not pass! + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Done. + publish_message::destroy(prepared_msg); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_transfer_tokens_outdated_version() { + use token_bridge::transfer_tokens::{prepare_transfer, transfer_tokens}; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let coin_10_balance = + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + let asset_info = state::verified_asset(&token_bridge_state); + + let relayer_fee = 0; + + let ( + ticket, + dust + ) = + prepare_transfer( + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + relayer_fee, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + let prepared_msg = + transfer_tokens(&mut token_bridge_state, ticket); + + // Clean up. + publish_message::destroy(prepared_msg); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/transfer_tokens_with_payload.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/transfer_tokens_with_payload.move new file mode 100644 index 0000000000..0ed204bfb7 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/transfer_tokens_with_payload.move @@ -0,0 +1,812 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements three methods: `prepare_transfer` and +/// `transfer_tokens_with_payload`, which are meant to work together. +/// +/// `prepare_transfer` allows a contract to pack token transfer parameters with +/// an arbitrary payload in preparation to bridge these assets to another +/// network. Only an `EmitterCap` has the capability to create +/// `TransferTicket`. The `EmitterCap` object ID is encoded as the +/// sender. +/// +/// `transfer_tokens_with_payload` unpacks the `TransferTicket` and +/// constructs a `MessageTicket`, which will be used by Wormhole's +/// `publish_message` module. +/// +/// The purpose of splitting this token transferring into two steps is in case +/// Token Bridge needs to be upgraded and there is a breaking change for this +/// module, an integrator would not be left broken. It is discouraged to put +/// `transfer_tokens_with_payload` in an integrator's package logic. Otherwise, +/// this integrator needs to be prepared to upgrade his contract to handle the +/// latest version of `transfer_tokens_with_payload`. +/// +/// Instead, an integrator is encouraged to execute a transaction block, which +/// executes `transfer_tokens_with_payload` using the latest Token Bridge +/// package ID and to implement `prepare_transfer` in his contract to produce +/// `PrepareTransferWithPayload`. +/// +/// NOTE: Only assets that exist in the `TokenRegistry` can be bridged out, +/// which are native Sui assets that have been attested for via `attest_token` +/// and wrapped foreign assets that have been created using foreign asset +/// metadata via the `create_wrapped` module. +/// +/// See `transfer_with_payload` module for serialization and deserialization of +/// Wormhole message payload. +module token_bridge::transfer_tokens_with_payload { + use sui::balance::{Balance}; + use sui::coin::{Coin}; + use sui::object::{Self, ID}; + use wormhole::bytes32::{Self}; + use wormhole::emitter::{EmitterCap}; + use wormhole::external_address::{Self}; + use wormhole::publish_message::{MessageTicket}; + + use token_bridge::normalized_amount::{NormalizedAmount}; + use token_bridge::state::{Self, State, LatestOnly}; + use token_bridge::token_registry::{VerifiedAsset}; + use token_bridge::transfer_with_payload::{Self}; + + /// This type represents transfer data for a specific redeemer contract on a + /// foreign chain. The only way to destroy this type is calling + /// `transfer_tokens_with_payload`. Only the owner of an `EmitterCap` has + /// the capability of generating `TransferTicket`. This emitter + /// cap will usually live in an integrator's contract storage object. + struct TransferTicket { + asset_info: VerifiedAsset, + bridged_in: Balance, + norm_amount: NormalizedAmount, + sender: ID, + redeemer_chain: u16, + redeemer: vector, + payload: vector, + nonce: u32 + } + + /// `prepare_transfer` constructs token transfer parameters. Any remaining + /// amount (A.K.A. dust) from the funds provided will be returned along with + /// the `TransferTicket` type. The returned coin object is the + /// same object moved into this method. + /// + /// NOTE: Integrators of Token Bridge should be calling only this method + /// from their contracts. This method is not guarded by version control + /// (thus not requiring a reference to the Token Bridge `State` object), so + /// it is intended to work for any package version. + public fun prepare_transfer( + emitter_cap: &EmitterCap, + asset_info: VerifiedAsset, + funded: Coin, + redeemer_chain: u16, + redeemer: vector, + payload: vector, + nonce: u32 + ): ( + TransferTicket, + Coin + ) { + use token_bridge::transfer_tokens::{take_truncated_amount}; + + let ( + bridged_in, + norm_amount + ) = take_truncated_amount(&asset_info, &mut funded); + + let prepared_transfer = + TransferTicket { + asset_info, + bridged_in, + norm_amount, + sender: object::id(emitter_cap), + redeemer_chain, + redeemer, + payload, + nonce + }; + + // The remaining amount of funded may have dust depending on the + // decimals of this asset. + (prepared_transfer, funded) + } + + /// `transfer_tokens_with_payload` is the only method that can unpack the + /// members of `TransferTicket`. This method takes the balance + /// from this type and bridges this asset out of Sui by either joining its + /// balance in the Token Bridge's custody for native assets or burning its + /// balance for wrapped assets. + /// + /// The unpacked sender ID comes from an `EmitterCap`. It is encoded as the + /// sender of these assets. And associated with this transfer is an + /// arbitrary payload, which can be consumed by the specified redeemer and + /// used as instructions for a contract composing with Token Bridge. + /// + /// This method returns the prepared Wormhole message (which should be + /// consumed by calling `publish_message` in a transaction block). + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + /// + /// It is important for integrators to refrain from calling this method + /// within their contracts. This method is meant to be called in a + /// transaction block after receiving a `TransferTicket` from calling + /// `prepare_transfer` within a contract. If in a circumstance where this + /// module has a breaking change in an upgrade, `prepare_transfer` will not + /// be affected by this change. + public fun transfer_tokens_with_payload( + token_bridge_state: &mut State, + prepared_transfer: TransferTicket + ): MessageTicket { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // Encode Wormhole message payload. + let ( + nonce, + encoded_transfer_with_payload + ) = + bridge_in_and_serialize_transfer( + &latest_only, + token_bridge_state, + prepared_transfer + ); + + // Prepare Wormhole message with encoded `TransferWithPayload`. + state::prepare_wormhole_message( + &latest_only, + token_bridge_state, + nonce, + encoded_transfer_with_payload + ) + } + + fun bridge_in_and_serialize_transfer( + latest_only: &LatestOnly, + token_bridge_state: &mut State, + prepared_transfer: TransferTicket + ): ( + u32, + vector + ) { + use token_bridge::transfer_tokens::{burn_or_deposit_funds}; + + let TransferTicket { + asset_info, + bridged_in, + norm_amount, + sender, + redeemer_chain, + redeemer, + payload, + nonce + } = prepared_transfer; + + let ( + token_chain, + token_address + ) = + burn_or_deposit_funds( + latest_only, + token_bridge_state, + &asset_info, + bridged_in + ); + + let redeemer = external_address::new(bytes32::from_bytes(redeemer)); + + let encoded = + transfer_with_payload::serialize( + transfer_with_payload::new( + sender, + norm_amount, + token_address, + token_chain, + redeemer, + redeemer_chain, + payload + ) + ); + + (nonce, encoded) + } + + #[test_only] + public fun bridge_in_and_serialize_transfer_test_only( + token_bridge_state: &mut State, + prepared_transfer: TransferTicket + ): ( + u32, + vector + ) { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + bridge_in_and_serialize_transfer( + &latest_only, + token_bridge_state, + prepared_transfer + ) + } +} + +#[test_only] +module token_bridge::transfer_tokens_with_payload_tests { + use sui::coin::{Self}; + use sui::object::{Self}; + use sui::test_scenario::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::emitter::{Self}; + use wormhole::external_address::{Self}; + use wormhole::publish_message::{Self}; + use wormhole::state::{chain_id}; + + use token_bridge::coin_wrapped_7::{Self, COIN_WRAPPED_7}; + use token_bridge::coin_native_10::{Self, COIN_NATIVE_10}; + use token_bridge::native_asset::{Self}; + use token_bridge::normalized_amount::{Self}; + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + set_up_wormhole_and_token_bridge, + register_dummy_emitter, + return_state, + take_state, + person + }; + use token_bridge::token_registry::{Self}; + use token_bridge::transfer_with_payload::{Self}; + use token_bridge::wrapped_asset::{Self}; + + /// Test consts. + const TEST_TARGET_RECIPIENT: vector = x"beef4269"; + const TEST_TARGET_CHAIN: u16 = 2; + const TEST_NONCE: u32 = 0; + const TEST_COIN_NATIVE_10_DECIMALS: u8 = 10; + const TEST_COIN_WRAPPED_7_DECIMALS: u8 = 7; + const TEST_MESSAGE_PAYLOAD: vector = x"deadbeefdeadbeef"; + + #[test] + fun test_transfer_tokens_with_payload_native_10() { + use token_bridge::transfer_tokens_with_payload::{ + prepare_transfer, + transfer_tokens_with_payload + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let coin_10_balance = + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Balance check the Token Bridge before executing the transfer. The + // initial balance should be zero for COIN_NATIVE_10. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == 0, 0); + }; + + // Register and obtain a new wormhole emitter cap. + let emitter_cap = emitter::dummy(); + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + prepared_transfer, + dust + ) = + prepare_transfer( + &emitter_cap, + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + TEST_MESSAGE_PAYLOAD, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Call `transfer_tokens_with_payload`. + let prepared_msg = + transfer_tokens_with_payload( + &mut token_bridge_state, + prepared_transfer + ); + + // Balance check the Token Bridge after executing the transfer. The + // balance should now reflect the `transfer_amount` defined in this + // test. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == transfer_amount, 0); + }; + + // Clean up. + publish_message::destroy(prepared_msg); + return_state(token_bridge_state); + emitter::destroy_test_only(emitter_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_transfer_tokens_native_10_with_dust_refund() { + use token_bridge::transfer_tokens_with_payload::{ + prepare_transfer, + transfer_tokens_with_payload + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 1000069; + let coin_10_balance = coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // This value will be used later. The contract should return dust + // to the caller since COIN_NATIVE_10 has 10 decimals. + let expected_dust = 69; + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Balance check the Token Bridge before executing the transfer. The + // initial balance should be zero for COIN_NATIVE_10. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!(native_asset::custody(asset) == 0, 0); + }; + + // Register and obtain a new wormhole emitter cap. + let emitter_cap = emitter::dummy(); + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + prepared_transfer, + dust + ) = + prepare_transfer( + &emitter_cap, + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + TEST_MESSAGE_PAYLOAD, + TEST_NONCE, + ); + assert!(coin::value(&dust) == expected_dust, 0); + + // Call `transfer_tokens`. + let prepared_msg = + transfer_tokens_with_payload( + &mut token_bridge_state, + prepared_transfer + ); + + // Balance check the Token Bridge after executing the transfer. The + // balance should now reflect the `transfer_amount` less `expected_dust` + // defined in this test. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_native(registry); + assert!( + native_asset::custody(asset) == transfer_amount - expected_dust, + 0 + ); + }; + + // Clean up. + publish_message::destroy(prepared_msg); + coin::burn_for_testing(dust); + emitter::destroy_test_only(emitter_cap); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_serialize_transfer_tokens_native_10() { + use token_bridge::transfer_tokens_with_payload::{ + bridge_in_and_serialize_transfer_test_only, + prepare_transfer + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let bridge_coin_10 = + coin::from_balance( + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ), + test_scenario::ctx(scenario) + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Register and obtain a new wormhole emitter cap. + let emitter_cap = emitter::dummy(); + + let asset_info = state::verified_asset(&token_bridge_state); + let expected_token_address = token_registry::token_address(&asset_info); + + let ( + prepared_transfer, + dust + ) = + prepare_transfer( + &emitter_cap, + asset_info, + bridge_coin_10, + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + TEST_MESSAGE_PAYLOAD, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Serialize the payload. + let ( + nonce, + payload + ) = + bridge_in_and_serialize_transfer_test_only( + &mut token_bridge_state, + prepared_transfer + ); + assert!(nonce == TEST_NONCE, 0); + + // Construct expected payload from scratch and confirm that the + // `transfer_tokens` call produces the same payload. + let expected_amount = normalized_amount::from_raw( + transfer_amount, + TEST_COIN_NATIVE_10_DECIMALS + ); + + let expected_payload = + transfer_with_payload::new_test_only( + object::id(&emitter_cap), + expected_amount, + expected_token_address, + chain_id(), + external_address::new(bytes32::from_bytes(TEST_TARGET_RECIPIENT)), + TEST_TARGET_CHAIN, + TEST_MESSAGE_PAYLOAD + ); + assert!( + transfer_with_payload::serialize(expected_payload) == payload, + 0 + ); + + // Clean up. + return_state(token_bridge_state); + emitter::destroy_test_only(emitter_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_transfer_tokens_with_payload_wrapped_7() { + use token_bridge::transfer_tokens_with_payload::{ + prepare_transfer, + transfer_tokens_with_payload + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let coin_7_balance = + coin_wrapped_7::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Balance check the Token Bridge before executing the transfer. The + // initial balance should be the `transfer_amount` for COIN_WRAPPED_7. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == transfer_amount, 0); + }; + + // Register and obtain a new wormhole emitter cap. + let emitter_cap = emitter::dummy(); + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + prepared_transfer, + dust + ) = + prepare_transfer( + &emitter_cap, + asset_info, + coin::from_balance( + coin_7_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + TEST_MESSAGE_PAYLOAD, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Call `transfer_tokens_with_payload`. + let prepared_msg = + transfer_tokens_with_payload( + &mut token_bridge_state, + prepared_transfer + ); + + // Balance check the Token Bridge after executing the transfer. The + // balance should be zero, since tokens are burned when an outbound + // wrapped token transfer occurs. + { + let registry = state::borrow_token_registry(&token_bridge_state); + let asset = token_registry::borrow_wrapped(registry); + assert!(wrapped_asset::total_supply(asset) == 0, 0); + }; + + // Clean up. + publish_message::destroy(prepared_msg); + emitter::destroy_test_only(emitter_cap); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_serialize_transfer_tokens_wrapped_7() { + use token_bridge::transfer_tokens_with_payload::{ + bridge_in_and_serialize_transfer_test_only, + prepare_transfer + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let bridged_coin_7 = + coin::from_balance( + coin_wrapped_7::init_register_and_mint( + scenario, + sender, + transfer_amount + ), + test_scenario::ctx(scenario) + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Register and obtain a new wormhole emitter cap. + let emitter_cap = emitter::dummy(); + + let asset_info = state::verified_asset(&token_bridge_state); + let expected_token_address = token_registry::token_address(&asset_info); + let expected_token_chain = token_registry::token_chain(&asset_info); + + let ( + prepared_transfer, + dust + ) = + prepare_transfer( + &emitter_cap, + asset_info, + bridged_coin_7, + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + TEST_MESSAGE_PAYLOAD, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Serialize the payload. + let ( + nonce, + payload + ) = + bridge_in_and_serialize_transfer_test_only( + &mut token_bridge_state, + prepared_transfer + ); + assert!(nonce == TEST_NONCE, 0); + + // Construct expected payload from scratch and confirm that the + // `transfer_tokens` call produces the same payload. + let expected_amount = normalized_amount::from_raw( + transfer_amount, + TEST_COIN_WRAPPED_7_DECIMALS + ); + + let expected_payload = + transfer_with_payload::new_test_only( + object::id(&emitter_cap), + expected_amount, + expected_token_address, + expected_token_chain, + external_address::new(bytes32::from_bytes(TEST_TARGET_RECIPIENT)), + TEST_TARGET_CHAIN, + TEST_MESSAGE_PAYLOAD + ); + assert!( + transfer_with_payload::serialize(expected_payload) == payload, + 0 + ); + + // Clean up. + emitter::destroy_test_only(emitter_cap); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_transfer_tokens_with_payload_outdated_version() { + use token_bridge::transfer_tokens_with_payload::{ + prepare_transfer, + transfer_tokens_with_payload + }; + + let sender = person(); + let my_scenario = test_scenario::begin(sender); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter on chain ID == 2. + register_dummy_emitter(scenario, TEST_TARGET_CHAIN); + + // Register and mint coins. + let transfer_amount = 6942000; + let coin_10_balance = + coin_native_10::init_register_and_mint( + scenario, + sender, + transfer_amount + ); + + // Ignore effects. + test_scenario::next_tx(scenario, sender); + + // Fetch objects necessary for sending the transfer. + let token_bridge_state = take_state(scenario); + + // Register and obtain a new wormhole emitter cap. + let emitter_cap = emitter::dummy(); + + let asset_info = state::verified_asset(&token_bridge_state); + let ( + prepared_transfer, + dust + ) = + prepare_transfer( + &emitter_cap, + asset_info, + coin::from_balance( + coin_10_balance, + test_scenario::ctx(scenario) + ), + TEST_TARGET_CHAIN, + TEST_TARGET_RECIPIENT, + TEST_MESSAGE_PAYLOAD, + TEST_NONCE, + ); + coin::destroy_zero(dust); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + let prepared_msg = + transfer_tokens_with_payload( + &mut token_bridge_state, + prepared_transfer + ); + + // Clean up. + publish_message::destroy(prepared_msg); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/utils/coin_utils.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/utils/coin_utils.move new file mode 100644 index 0000000000..80d351f933 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/utils/coin_utils.move @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements utilities helpful for outbound token transfers. These +/// utility methods should also help avoid having to work around conversions +/// between `Coin` and `Balance` avoiding unnecessary object creation and +/// destruction. +module token_bridge::coin_utils { + use sui::balance::{Self, Balance}; + use sui::coin::{Self, Coin}; + use sui::tx_context::{TxContext}; + + /// Method similar to `coin::take` where an amount is split from a `Coin` + /// object's inner balance. + public fun take_balance( + coin_mut: &mut Coin, + amount: u64 + ): Balance { + balance::split(coin::balance_mut(coin_mut), amount) + } + + /// Method out of convenience to take the full balance value out of a `Coin` + /// object while preserving that object. This method is used to avoid + /// calling `coin::into_balance` which destroys the object. + public fun take_full_balance(coin_mut: &mut Coin): Balance { + let amount = coin::value(coin_mut); + take_balance(coin_mut, amount) + } + + /// Method similar to `coin::put` where an outside balance is joined with + /// an existing `Coin` object. + public fun put_balance( + coin_mut: &mut Coin, + the_balance: Balance + ): u64 { + balance::join(coin::balance_mut(coin_mut), the_balance) + } + + /// Method for those integrators that use `Coin` objects, where `the_coin` + /// will be destroyed if the value is zero. Otherwise it will be returned + /// back to the transaction sender. + public fun return_nonzero(the_coin: Coin, ctx: &TxContext) { + if (coin::value(&the_coin) == 0) { + coin::destroy_zero(the_coin); + } else { + sui::pay::keep(the_coin, ctx) + } + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/utils/string_utils.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/utils/string_utils.move new file mode 100644 index 0000000000..868fa74927 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/utils/string_utils.move @@ -0,0 +1,97 @@ +module token_bridge::string_utils { + use std::ascii::{Self}; + use std::string::{Self, String}; + use std::vector::{Self}; + + const QUESTION_MARK: u8 = 63; + // Recall that UTF-8 characters have variable-length encoding and can have + // 1, 2, 3, or 4 bytes. + // The first byte of the 2, 3, and 4-byte UTF-8 characters have a special + // form indicating how many more bytes follow in the same character + // representation. Specifically, it can have the forms + // - 110xxxxx // 11000000 is 192 (base 10) + // - 1110xxxx // 11100000 is 224 (base 10) + // - or 11110xxx // 11110000 is 240 (base 10) + // + // We can tell the length the a hex UTF-8 character in bytes by looking + // at the first byte and counting the leading 1's, or alternatively + // seeing whether it falls in the range + // [11000000, 11100000) or [11100000, 11110000) or [11110000, 11111111], + // + // The following constants demarcate those ranges and are used in the + // string32::to_ascii function. + const UTF8_LENGTH_2_FIRST_BYTE_LOWER_BOUND: u8 = 192; + const UTF8_LENGTH_3_FIRST_BYTE_LOWER_BOUND: u8 = 224; + const UTF8_LENGTH_4_FIRST_BYTE_LOWER_BOUND: u8 = 240; + + /// Converts a String32 to an ascii string if possible, otherwise errors + /// out at `ascii::string(bytes)`. For input strings that contain non-ascii + /// characters, we will swap the non-ascii character with `?`. + /// + /// Note that while the Sui spec limits symbols to only use ascii + /// characters, the token bridge spec does allow utf8 symbols. + public fun to_ascii(s: &String): ascii::String { + let buf = *string::bytes(s); + // keep dropping the last character while it's 0 + while ( + !vector::is_empty(&buf) && + *vector::borrow(&buf, vector::length(&buf) - 1) == 0 + ) { + vector::pop_back(&mut buf); + }; + + // Run through `buf` to convert any non-ascii character to `?`. + let asciified = vector::empty(); + let (i, n) = (0, vector::length(&buf)); + while (i < n) { + let b = *vector::borrow(&buf, i); + // If it is a valid ascii character, keep it. + if (ascii::is_valid_char(b)) { + vector::push_back(&mut asciified, b); + i = i + 1; + } else { + // Since UTF-8 characters have variable-length encoding (they are + // represented using 1-4 bytes, unlike ASCII characters, which + // are represented using 1 byte), we don't want to transform + // every byte in a UTF-8 string that does not represent an ASCII + // character to the question mark symbol "?". This would result + // in having too many "?" symbols. + // + // Instead, we want a single "?" for each character. Note that + // the 1-byte UTF-8 characters correspond to valid ASCII + // characters and have the form 0xxxxxxx. + // The 2, 3, and 4-byte UTF-8 characters have first byte equal + // to: + // - 110xxxxx // 192 + // - 1110xxxx // 224 + // - or 11110xxx // 240 + // + // and remaining bytes of the form: + // - 10xxxxxx + // + // To ensure a one-to-one mapping of a multi-byte UTF-8 character + // to a "?", we detect the first byte of a new UTF-8 character + // in a multi-byte representation by checking if it is + // >= 11000000 (base 2) or 192 (base 10) and convert it to a "?" + // and skip the remaining bytes in the same representation. + // + // + // Reference: https://en.wikipedia.org/wiki/UTF-8 + if (b >= UTF8_LENGTH_2_FIRST_BYTE_LOWER_BOUND){ + vector::push_back(&mut asciified, QUESTION_MARK); + if (b >= UTF8_LENGTH_4_FIRST_BYTE_LOWER_BOUND){ + // The UTF-8 char has a 4-byte hex representation. + i = i + 4; + } else if (b >= UTF8_LENGTH_3_FIRST_BYTE_LOWER_BOUND){ + // The UTF-8 char has a 3-byte hex representation. + i = i + 3; + } else { + // The UTF-8 char has a 2-byte hex representation. + i = i + 2; + } + } + }; + }; + ascii::string(asciified) + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/vaa.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/vaa.move new file mode 100644 index 0000000000..c2e9a26096 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/vaa.move @@ -0,0 +1,351 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module builds on Wormhole's `vaa::parse_and_verify` method by adding +/// emitter verification and replay protection. +/// +/// Token Bridge only cares about other Token Bridge messages, so the emitter +/// address must be a registered Token Bridge emitter according to the VAA's +/// emitter chain ID. +/// +/// Token Bridge does not allow replaying any of its VAAs, so its hash is stored +/// in its `State`. If the encoded VAA passes through `parse_and_verify` again, +/// it will abort. +module token_bridge::vaa { + use sui::table::{Self}; + use wormhole::external_address::{ExternalAddress}; + use wormhole::vaa::{Self, VAA}; + + use token_bridge::state::{Self, State}; + + friend token_bridge::create_wrapped; + friend token_bridge::complete_transfer; + friend token_bridge::complete_transfer_with_payload; + + /// For a given chain ID, Token Bridge is non-existent. + const E_UNREGISTERED_EMITTER: u64 = 0; + /// Encoded emitter address does not match registered Token Bridge. + const E_EMITTER_ADDRESS_MISMATCH: u64 = 1; + + /// This type represents VAA data whose emitter is a registered Token Bridge + /// emitter. This message is also representative of a VAA that cannot be + /// replayed. + struct TokenBridgeMessage { + /// Wormhole chain ID from which network the message originated from. + emitter_chain: u16, + /// Address of Token Bridge (standardized to 32 bytes) that produced + /// this message. + emitter_address: ExternalAddress, + /// Sequence number of Token Bridge's Wormhole message. + sequence: u64, + /// Token Bridge payload. + payload: vector + } + + /// Parses and verifies encoded VAA. Because Token Bridge does not allow + /// VAAs to be replayed, the VAA hash is stored in a set, which is checked + /// against the next time the same VAA is used to make sure it cannot be + /// used again. + /// + /// In its verification, this method checks whether the emitter is a + /// registered Token Bridge contract on another network. + /// + /// NOTE: It is important for integrators to refrain from calling this + /// method within their contracts. This method is meant to be called within + /// a transaction block, passing the `TokenBridgeMessage` to one of the + /// Token Bridge methods that consumes this type. If in a circumstance where + /// this module has a breaking change in an upgrade, another method (e.g. + /// `complete_transfer_with_payload`) will not be affected by this change. + public fun verify_only_once( + token_bridge_state: &mut State, + verified_vaa: VAA + ): TokenBridgeMessage { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(token_bridge_state); + + // First parse and verify VAA using Wormhole. This also consumes the VAA + // hash to prevent replay. + vaa::consume( + state::borrow_mut_consumed_vaas(&latest_only, token_bridge_state), + &verified_vaa + ); + + // Does the emitter agree with a registered Token Bridge? + assert_registered_emitter(token_bridge_state, &verified_vaa); + + // Take emitter info, sequence and payload. + let sequence = vaa::sequence(&verified_vaa); + let ( + emitter_chain, + emitter_address, + payload + ) = vaa::take_emitter_info_and_payload(verified_vaa); + + TokenBridgeMessage { + emitter_chain, + emitter_address, + sequence, + payload + } + } + + public fun emitter_chain(self: &TokenBridgeMessage): u16 { + self.emitter_chain + } + + public fun emitter_address(self: &TokenBridgeMessage): ExternalAddress { + self.emitter_address + } + + public fun sequence(self: &TokenBridgeMessage): u64 { + self.sequence + } + + /// Destroy `TokenBridgeMessage` and extract payload, which is the same + /// payload in the `VAA`. + /// + /// NOTE: This is a privileged method, which only friends within the Token + /// Bridge package can use. This guarantees that no other package can redeem + /// a VAA intended for Token Bridge as a denial-of-service by calling + /// `verify_only_once` and then destroying it by calling it this method. + public(friend) fun take_payload(msg: TokenBridgeMessage): vector { + let TokenBridgeMessage { + emitter_chain: _, + emitter_address: _, + sequence: _, + payload + } = msg; + + payload + } + + /// Assert that a given emitter equals one that is registered as a foreign + /// Token Bridge. + fun assert_registered_emitter( + token_bridge_state: &State, + verified_vaa: &VAA + ) { + let chain = vaa::emitter_chain(verified_vaa); + let registry = state::borrow_emitter_registry(token_bridge_state); + assert!(table::contains(registry, chain), E_UNREGISTERED_EMITTER); + + let registered = table::borrow(registry, chain); + let emitter_addr = vaa::emitter_address(verified_vaa); + assert!(*registered == emitter_addr, E_EMITTER_ADDRESS_MISMATCH); + } + + #[test_only] + public fun destroy(msg: TokenBridgeMessage) { + take_payload(msg); + } +} + +#[test_only] +module token_bridge::vaa_tests { + use sui::test_scenario::{Self}; + use wormhole::external_address::{Self}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + use token_bridge::state::{Self}; + use token_bridge::token_bridge_scenario::{ + person, + register_dummy_emitter, + return_state, + set_up_wormhole_and_token_bridge, + take_state + }; + use token_bridge::vaa::{Self}; + + /// VAA sent from the ethereum token bridge 0xdeadbeef. + const VAA: vector = + x"01000000000100102d399190fa61daccb11c2ea4f7a3db3a9365e5936bcda4cded87c1b9eeb095173514f226256d5579af71d4089eb89496befb998075ba94cd1d4460c5c57b84000000000100000001000200000000000000000000000000000000000000000000000000000000deadbeef0000000002634973000200000000000000000000000000000000000000000000000000000000beefface00020c0000000000000000000000000000000000000000000000000000000042454546000000000000000000000000000000000042656566206661636520546f6b656e"; + + #[test] + #[expected_failure(abort_code = vaa::E_UNREGISTERED_EMITTER)] + fun test_cannot_verify_only_once_unregistered_chain() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + // You shall not pass! + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Clean up. + vaa::destroy(msg); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = vaa::E_EMITTER_ADDRESS_MISMATCH)] + fun test_cannot_verify_only_once_emitter_address_mismatch() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + // First register emitter. + let emitter_chain = 2; + let emitter_addr = external_address::from_address(@0xdeafbeef); + token_bridge::register_chain::register_new_emitter_test_only( + &mut token_bridge_state, + emitter_chain, + emitter_addr + ); + + // Confirm that encoded emitter disagrees with registered emitter. + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + assert!( + wormhole::vaa::emitter_address(&verified_vaa) != emitter_addr, + 0 + ); + + // You shall not pass! + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Clean up. + vaa::destroy(msg); + + abort 42 + } + + #[test] + fun test_verify_only_once() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + // Confirm VAA originated from where we expect. + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + assert!( + wormhole::vaa::emitter_chain(&verified_vaa) == expected_source_chain, + 0 + ); + + // Finally verify. + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Clean up. + vaa::destroy(msg); + return_state(token_bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::set::E_KEY_ALREADY_EXISTS)] + fun test_cannot_verify_only_once_again() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + // Confirm VAA originated from where we expect. + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + assert!( + wormhole::vaa::emitter_chain(&verified_vaa) == expected_source_chain, + 0 + ); + + // Finally verify. + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + vaa::destroy(msg); + + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + // You shall not pass! + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Clean up. + vaa::destroy(msg); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_verify_only_once_outdated_version() { + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Set up contracts. + let wormhole_fee = 350; + set_up_wormhole_and_token_bridge(scenario, wormhole_fee); + + // Register foreign emitter. + let expected_source_chain = 2; + register_dummy_emitter(scenario, expected_source_chain); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let token_bridge_state = take_state(scenario); + + // Verify VAA. + let verified_vaa = parse_and_verify_vaa(scenario, VAA); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut token_bridge_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut token_bridge_state, + token_bridge::version_control::previous_version_test_only(), + token_bridge::version_control::next_version() + ); + + // You shall not pass! + let msg = vaa::verify_only_once(&mut token_bridge_state, verified_vaa); + + // Clean up. + vaa::destroy(msg); + + abort 42 + } + +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/version_control.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/version_control.move new file mode 100644 index 0000000000..caee75794c --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/token_bridge/sources/version_control.move @@ -0,0 +1,72 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements dynamic field keys as empty structs. These keys are +/// used to determine the latest version for this build. If the current version +/// is not this build's, then paths through the `state` module will abort. +/// +/// See `token_bridge::state` and `wormhole::package_utils` for more info. +module token_bridge::version_control { + //////////////////////////////////////////////////////////////////////////// + // + // Hard-coded Version Control + // + // Before upgrading, please set the types for `current_version` and + // `previous_version` to match the correct types (current being the latest + // version reflecting this build). + // + //////////////////////////////////////////////////////////////////////////// + + public(friend) fun current_version(): V__0_2_0 { + V__0_2_0 {} + } + + #[test_only] + public fun current_version_test_only(): V__0_2_0 { + current_version() + } + + public(friend) fun previous_version(): V__DUMMY { + V__DUMMY {} + } + + #[test_only] + public fun previous_version_test_only(): V__DUMMY { + previous_version() + } + + //////////////////////////////////////////////////////////////////////////// + // + // Change Log + // + // Please write release notes as doc strings for each version struct. These + // notes will be our attempt at tracking upgrades. Wish us luck. + // + //////////////////////////////////////////////////////////////////////////// + + /// First published package on Sui mainnet. + struct V__0_2_0 has store, drop, copy {} + + // Dummy. + struct V__DUMMY has store, drop, copy {} + + //////////////////////////////////////////////////////////////////////////// + // + // Implementation and Test-Only Methods + // + //////////////////////////////////////////////////////////////////////////// + + friend token_bridge::state; + + #[test_only] + public fun dummy(): V__DUMMY { + V__DUMMY {} + } + + #[test_only] + struct V__MIGRATED has store, drop, copy {} + + #[test_only] + public fun next_version(): V__MIGRATED { + V__MIGRATED {} + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/.gitignore b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/.gitignore new file mode 100644 index 0000000000..378eac25d3 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/.gitignore @@ -0,0 +1 @@ +build diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Makefile b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Makefile new file mode 100644 index 0000000000..1f9d45f8af --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Makefile @@ -0,0 +1,18 @@ +-include ../../Makefile.help + +VERSION = $(shell grep -Po "version = \"\K[^\"]*" Move.toml | sed "s/\./_/g") + +.PHONY: clean +clean: + rm -rf build + +.PHONY: check +## Build contract +check: + sui move build -d + +.PHONY: test +## Run tests +test: check + grep "public(friend) fun current_version(): V__${VERSION} {" sources/version_control.move + sui move test -d -t 1 diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.devnet.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.devnet.toml new file mode 100644 index 0000000000..ba3f5e54aa --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.devnet.toml @@ -0,0 +1,11 @@ +[package] +name = "Wormhole" +version = "0.2.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[addresses] +wormhole = "_" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.lock b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.lock new file mode 100644 index 0000000000..570d17a100 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.lock @@ -0,0 +1,27 @@ +# @generated by Move, please check-in and do not edit manually. + +[move] +version = 0 +manifest_digest = "E8C411A83F4F7EF268B73C732B9B6F49F7B204F0C9C2530765365C38B76EF646" +deps_digest = "F8BBB0CCB2491CA29A3DF03D6F92277A4F3574266507ACD77214D37ECA3F3082" + +dependencies = [ + { name = "Sui" }, +] + +[[move.package]] +name = "MoveStdlib" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/move-stdlib" } + +[[move.package]] +name = "Sui" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/sui-framework" } + +dependencies = [ + { name = "MoveStdlib" }, +] + +[move.toolchain-version] +compiler-version = "1.19.0" +edition = "legacy" +flavor = "sui" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.mainnet.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.mainnet.toml new file mode 100644 index 0000000000..7465390ebb --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.mainnet.toml @@ -0,0 +1,12 @@ +[package] +name = "Wormhole" +version = "0.2.0" +published-at = "0x5306f64e312b581766351c07af79c72fcb1cd25147157fdc2f8ad76de9a3fb6a" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[addresses] +wormhole = "0x5306f64e312b581766351c07af79c72fcb1cd25147157fdc2f8ad76de9a3fb6a" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.testnet.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.testnet.toml new file mode 100644 index 0000000000..ed34ccb472 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.testnet.toml @@ -0,0 +1,12 @@ +[package] +name = "Wormhole" +version = "0.2.0" +published-at = "0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[addresses] +wormhole = "0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.toml b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.toml new file mode 100644 index 0000000000..42fe952451 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/Move.toml @@ -0,0 +1,12 @@ +[package] +name = "Wormhole" +version = "0.2.0" +published-at = "0x23a373b70e6e23a39e4846fa6896fa12beb08da061b3d4ec856bc8ead54f1e22" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" + +[addresses] +wormhole = "0x23a373b70e6e23a39e4846fa6896fa12beb08da061b3d4ec856bc8ead54f1e22" diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/README.md b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/README.md new file mode 100644 index 0000000000..62a62a67b1 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/README.md @@ -0,0 +1,25 @@ +# Sui Wormhole Core Bridge Design + +## State + +The `State` object is created exactly once during the initialisation of the +contract. Normally, run-once functionality is implemented in the special `init` +function of a module (this code runs once, when the module is first deployed), +but this function takes no arguments, while our initialisation code does (to +ease deployment to different environments without recompiling the contract). + +To allow configuring the state with arguments, it's initialised in the +`init_and_share_state` function, which also shares the state object. To ensure +this function can only be called once, it consumes a `DeployerCap` object +which in turn is created and transferred to the deployer in the `init` function. +Since `init_and_share_state` consumes this object, it won't be possible to call +it again. + +## Dynamic fields + +TODO: up to date notes on where and how we use dynamic fields. + +## Epoch Timestamp + +Sui currently does not have fine-grained timestamps, so we use +`tx_context::epoch(ctx)` in place of on-chain time in seconds. diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/datatypes/bytes20.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/datatypes/bytes20.move new file mode 100644 index 0000000000..3c097dec69 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/datatypes/bytes20.move @@ -0,0 +1,176 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type representing a fixed-size array of +/// length 20. +module wormhole::bytes20 { + use std::vector::{Self}; + + use wormhole::bytes::{Self}; + use wormhole::cursor::{Cursor}; + + /// Invalid vector length to create `Bytes20`. + const E_INVALID_BYTES20: u64 = 0; + /// Found non-zero bytes when attempting to trim `vector`. + const E_CANNOT_TRIM_NONZERO: u64 = 1; + + /// 20. + const LEN: u64 = 20; + + /// Container for `vector`, which has length == 20. + struct Bytes20 has copy, drop, store { + data: vector + } + + public fun length(): u64 { + LEN + } + + /// Create new `Bytes20`, which checks the length of input `data`. + public fun new(data: vector): Bytes20 { + assert!(is_valid(&data), E_INVALID_BYTES20); + Bytes20 { data } + } + + /// Create new `Bytes20` of all zeros. + public fun default(): Bytes20 { + let data = vector::empty(); + let i = 0; + while (i < LEN) { + vector::push_back(&mut data, 0); + i = i + 1; + }; + new(data) + } + + /// Retrieve underlying `data`. + public fun data(self: &Bytes20): vector { + self.data + } + + /// Either trim or pad (depending on length of the input `vector`) to 20 + /// bytes. + public fun from_bytes(buf: vector): Bytes20 { + let len = vector::length(&buf); + if (len > LEN) { + trim_nonzero_left(&mut buf); + new(buf) + } else { + new(pad_left(&buf, false)) + } + } + + /// Destroy `Bytes20` for its underlying data. + public fun to_bytes(value: Bytes20): vector { + let Bytes20 { data } = value; + data + } + + /// Drain 20 elements of `Cursor` to create `Bytes20`. + public fun take(cur: &mut Cursor): Bytes20 { + new(bytes::take_bytes(cur, LEN)) + } + + /// Validate that any of the bytes in underlying data is non-zero. + public fun is_nonzero(self: &Bytes20): bool { + let i = 0; + while (i < LEN) { + if (*vector::borrow(&self.data, i) > 0) { + return true + }; + i = i + 1; + }; + + false + } + + /// Check that the input data is correct length. + fun is_valid(data: &vector): bool { + vector::length(data) == LEN + } + + /// For vector size less than 20, add zeros to the left. + fun pad_left(data: &vector, data_reversed: bool): vector { + let out = vector::empty(); + let len = vector::length(data); + let i = len; + while (i < LEN) { + vector::push_back(&mut out, 0); + i = i + 1; + }; + if (data_reversed) { + let i = 0; + while (i < len) { + vector::push_back( + &mut out, + *vector::borrow(data, len - i - 1) + ); + i = i + 1; + }; + } else { + vector::append(&mut out, *data); + }; + + out + } + + /// Trim bytes from the left if they are zero. If any of these bytes + /// are non-zero, abort. + fun trim_nonzero_left(data: &mut vector) { + vector::reverse(data); + let (i, n) = (0, vector::length(data) - LEN); + while (i < n) { + assert!(vector::pop_back(data) == 0, E_CANNOT_TRIM_NONZERO); + i = i + 1; + }; + vector::reverse(data); + } +} + +#[test_only] +module wormhole::bytes20_tests { + use std::vector::{Self}; + + use wormhole::bytes20::{Self}; + + #[test] + public fun new() { + let data = x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + assert!(vector::length(&data) == 20, 0); + let actual = bytes20::new(data); + + assert!(bytes20::data(&actual) == data, 0); + } + + #[test] + public fun default() { + let actual = bytes20::default(); + let expected = x"0000000000000000000000000000000000000000"; + assert!(bytes20::data(&actual) == expected, 0); + } + + #[test] + public fun from_bytes() { + let actual = bytes20::from_bytes(x"deadbeef"); + let expected = x"00000000000000000000000000000000deadbeef"; + assert!(bytes20::data(&actual) == expected, 0); + } + + #[test] + public fun is_nonzero() { + let data = x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + let actual = bytes20::new(data); + assert!(bytes20::is_nonzero(&actual), 0); + + let zeros = bytes20::default(); + assert!(!bytes20::is_nonzero(&zeros), 0); + } + + #[test] + #[expected_failure(abort_code = bytes20::E_INVALID_BYTES20)] + public fun cannot_new_non_20_byte_vector() { + let data = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbe"; + assert!(vector::length(&data) != 20, 0); + bytes20::new(data); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/datatypes/bytes32.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/datatypes/bytes32.move new file mode 100644 index 0000000000..ab713f6f25 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/datatypes/bytes32.move @@ -0,0 +1,287 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type representing a fixed-size array of +/// length 32. +module wormhole::bytes32 { + use std::option::{Self}; + use std::string::{Self, String}; + use std::vector::{Self}; + use sui::bcs::{Self}; + + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self, Cursor}; + + /// Invalid vector length to create `Bytes32`. + const E_INVALID_BYTES32: u64 = 0; + /// Found non-zero bytes when attempting to trim `vector`. + const E_CANNOT_TRIM_NONZERO: u64 = 1; + /// Value of deserialized 32-byte array data overflows u64 max. + const E_U64_OVERFLOW: u64 = 2; + + /// 32. + const LEN: u64 = 32; + + /// Container for `vector`, which has length == 32. + struct Bytes32 has copy, drop, store { + data: vector, + } + + public fun length(): u64 { + LEN + } + + /// Create new `Bytes32`, which checks the length of input `data`. + public fun new(data: vector): Bytes32 { + assert!(is_valid(&data), E_INVALID_BYTES32); + Bytes32 { data } + } + + /// Create new `Bytes20` of all zeros. + public fun default(): Bytes32 { + let data = vector::empty(); + let i = 0; + while (i < LEN) { + vector::push_back(&mut data, 0); + i = i + 1; + }; + new(data) + } + + /// Retrieve underlying `data`. + public fun data(self: &Bytes32): vector { + self.data + } + + /// Serialize `u256` as big-endian format in zero-padded `Bytes32`. + public fun from_u256_be(value: u256): Bytes32 { + let buf = bcs::to_bytes(&value); + vector::reverse(&mut buf); + new(buf) + } + + /// Deserialize from big-endian `u256`. + public fun to_u256_be(value: Bytes32): u256 { + let cur = cursor::new(to_bytes(value)); + let out = bytes::take_u256_be(&mut cur); + cursor::destroy_empty(cur); + + out + } + + /// Serialize `u64` as big-endian format in zero-padded `Bytes32`. + public fun from_u64_be(value: u64): Bytes32 { + from_u256_be((value as u256)) + } + + /// Deserialize from big-endian `u64` as long as the data does not + /// overflow. + public fun to_u64_be(value: Bytes32): u64 { + let num = to_u256_be(value); + assert!(num < (1u256 << 64), E_U64_OVERFLOW); + (num as u64) + } + + /// Either trim or pad (depending on length of the input `vector`) to 32 + /// bytes. + public fun from_bytes(buf: vector): Bytes32 { + let len = vector::length(&buf); + if (len > LEN) { + trim_nonzero_left(&mut buf); + new(buf) + } else { + new(pad_left(&buf, false)) + } + } + + /// Destroy `Bytes32` for its underlying data. + public fun to_bytes(value: Bytes32): vector { + let Bytes32 { data } = value; + data + } + + /// Drain 32 elements of `Cursor` to create `Bytes32`. + public fun take_bytes(cur: &mut Cursor): Bytes32 { + new(bytes::take_bytes(cur, LEN)) + } + + /// Destroy `Bytes32` to represent its underlying data as `address`. + public fun to_address(value: Bytes32): address { + sui::address::from_bytes(to_bytes(value)) + } + + /// Create `Bytes32` from `address`. + public fun from_address(addr: address): Bytes32 { + new(sui::address::to_bytes(addr)) + } + + public fun from_utf8(str: String): Bytes32 { + let data = *string::bytes(&str); + let len = vector::length(&data); + if (len > LEN) { + // Trim from end. + let i = len; + while (i > LEN) { + vector::pop_back(&mut data); + i = i - 1; + } + } else { + // Pad right to `LEN`. + let i = len; + while (i < LEN) { + vector::push_back(&mut data, 0); + i = i + 1; + } + }; + + new(data) + } + + /// Even if the input is valid utf8, the result might be shorter than 32 + /// bytes, because the original string might have a multi-byte utf8 + /// character at the 32 byte boundary, which, when split, results in an + /// invalid code point, so we remove it. + public fun to_utf8(value: Bytes32): String { + let data = to_bytes(value); + + let utf8 = string::try_utf8(data); + while (option::is_none(&utf8)) { + vector::pop_back(&mut data); + utf8 = string::try_utf8(data); + }; + + let buf = *string::bytes(&option::extract(&mut utf8)); + + // Now trim zeros from the right. + while ( + *vector::borrow(&buf, vector::length(&buf) - 1) == 0 + ) { + vector::pop_back(&mut buf); + }; + + string::utf8(buf) + } + + /// Validate that any of the bytes in underlying data is non-zero. + public fun is_nonzero(self: &Bytes32): bool { + let i = 0; + while (i < LEN) { + if (*vector::borrow(&self.data, i) > 0) { + return true + }; + i = i + 1; + }; + + false + } + + /// Check that the input data is correct length. + fun is_valid(data: &vector): bool { + vector::length(data) == LEN + } + + /// For vector size less than 32, add zeros to the left. + fun pad_left(data: &vector, data_reversed: bool): vector { + let out = vector::empty(); + let len = vector::length(data); + let i = len; + while (i < LEN) { + vector::push_back(&mut out, 0); + i = i + 1; + }; + if (data_reversed) { + let i = 0; + while (i < len) { + vector::push_back( + &mut out, + *vector::borrow(data, len - i - 1) + ); + i = i + 1; + }; + } else { + vector::append(&mut out, *data); + }; + + out + } + + /// Trim bytes from the left if they are zero. If any of these bytes + /// are non-zero, abort. + fun trim_nonzero_left(data: &mut vector) { + vector::reverse(data); + let (i, n) = (0, vector::length(data) - LEN); + while (i < n) { + assert!(vector::pop_back(data) == 0, E_CANNOT_TRIM_NONZERO); + i = i + 1; + }; + vector::reverse(data); + } +} + +#[test_only] +module wormhole::bytes32_tests { + use std::vector::{Self}; + + use wormhole::bytes32::{Self}; + + #[test] + public fun new() { + let data = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + assert!(vector::length(&data) == 32, 0); + let actual = bytes32::new(data); + + assert!(bytes32::data(&actual) == data, 0); + } + + #[test] + public fun default() { + let actual = bytes32::default(); + let expected = + x"0000000000000000000000000000000000000000000000000000000000000000"; + assert!(bytes32::data(&actual) == expected, 0); + } + + #[test] + public fun from_u256_be() { + let actual = bytes32::from_u256_be(1 << 32); + let expected = + x"0000000000000000000000000000000000000000000000000000000100000000"; + assert!(bytes32::data(&actual) == expected, 0); + } + + #[test] + public fun to_u256_be() { + let actual = bytes32::new( + x"0000000000000000000000000000000000000000000000000000000100000000" + ); + assert!(bytes32::to_u256_be(actual) == (1 << 32), 0); + } + + #[test] + public fun from_bytes() { + let actual = bytes32::from_bytes(x"deadbeef"); + let expected = + x"00000000000000000000000000000000000000000000000000000000deadbeef"; + assert!(bytes32::data(&actual) == expected, 0); + } + + #[test] + public fun is_nonzero() { + let data = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + let actual = bytes32::new(data); + assert!(bytes32::is_nonzero(&actual), 0); + + let zeros = bytes32::default(); + assert!(!bytes32::is_nonzero(&zeros), 0); + } + + #[test] + #[expected_failure(abort_code = bytes32::E_INVALID_BYTES32)] + public fun cannot_new_non_32_byte_vector() { + let data = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbe"; + assert!(vector::length(&data) != 32, 0); + bytes32::new(data); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/datatypes/external_address.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/datatypes/external_address.move new file mode 100644 index 0000000000..b2134caf35 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/datatypes/external_address.move @@ -0,0 +1,102 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type for a 32-byte standardized address, +/// which is meant to represent an address from any other network. +module wormhole::external_address { + use sui::object::{Self, ID}; + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::cursor::{Cursor}; + + /// Underlying data is all zeros. + const E_ZERO_ADDRESS: u64 = 0; + + /// Container for `Bytes32`. + struct ExternalAddress has copy, drop, store { + value: Bytes32, + } + + /// Create `ExternalAddress`. + public fun new(value: Bytes32): ExternalAddress { + ExternalAddress { value } + } + + /// Create `ExternalAddress` of all zeros.` + public fun default(): ExternalAddress { + new(bytes32::default()) + } + + /// Create `ExternalAddress` ensuring that not all bytes are zero. + public fun new_nonzero(value: Bytes32): ExternalAddress { + assert!(bytes32::is_nonzero(&value), E_ZERO_ADDRESS); + new(value) + } + + /// Destroy `ExternalAddress` for underlying bytes as `vector`. + public fun to_bytes(ext: ExternalAddress): vector { + bytes32::to_bytes(to_bytes32(ext)) + } + + /// Destroy 'ExternalAddress` for underlying data. + public fun to_bytes32(ext: ExternalAddress): Bytes32 { + let ExternalAddress { value } = ext; + value + } + + /// Drain 32 elements of `Cursor` to create `ExternalAddress`. + public fun take_bytes(cur: &mut Cursor): ExternalAddress { + new(bytes32::take_bytes(cur)) + } + + /// Drain 32 elements of `Cursor` to create `ExternalAddress` ensuring + /// that not all bytes are zero. + public fun take_nonzero(cur: &mut Cursor): ExternalAddress { + new_nonzero(bytes32::take_bytes(cur)) + } + + /// Destroy `ExternalAddress` to represent its underlying data as `address`. + public fun to_address(ext: ExternalAddress): address { + sui::address::from_bytes(to_bytes(ext)) + } + + /// Create `ExternalAddress` from `address`. + public fun from_address(addr: address): ExternalAddress { + new(bytes32::from_address(addr)) + } + + /// Create `ExternalAddress` from `ID`. + public fun from_id(id: ID): ExternalAddress { + new(bytes32::from_bytes(object::id_to_bytes(&id))) + } + + /// Check whether underlying data is not all zeros. + public fun is_nonzero(self: &ExternalAddress): bool { + bytes32::is_nonzero(&self.value) + } +} + +#[test_only] +module wormhole::external_address_tests { + use wormhole::bytes32::{Self}; + use wormhole::external_address::{Self}; + + #[test] + public fun test_bytes() { + let data = + bytes32::new( + x"1234567891234567891234567891234512345678912345678912345678912345" + ); + let addr = external_address::new(data); + assert!(external_address::to_bytes(addr) == bytes32::to_bytes(data), 0); + } + + #[test] + public fun test_address() { + let data = + bytes32::new( + x"0000000000000000000000000000000000000000000000000000000000001234" + ); + let addr = external_address::new(data); + assert!(external_address::to_address(addr) == @0x1234, 0); + assert!(addr == external_address::from_address(@0x1234), 0); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/datatypes/guardian_signature.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/datatypes/guardian_signature.move new file mode 100644 index 0000000000..58698d51a6 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/datatypes/guardian_signature.move @@ -0,0 +1,64 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type representing a Guardian's signature +/// with recovery ID of a particular hashed VAA message body. The components of +/// `GuardianSignature` are used to perform public key recovery using ECDSA. +module wormhole::guardian_signature { + use std::vector::{Self}; + + use wormhole::bytes32::{Self, Bytes32}; + + /// Container for elliptic curve signature parameters and Guardian index. + struct GuardianSignature has store, drop { + r: Bytes32, + s: Bytes32, + recovery_id: u8, + index: u8, + } + + /// Create new `GuardianSignature`. + public fun new( + r: Bytes32, + s: Bytes32, + recovery_id: u8, + index: u8 + ): GuardianSignature { + GuardianSignature { r, s, recovery_id, index } + } + + /// 32-byte signature parameter R. + public fun r(self: &GuardianSignature): Bytes32 { + self.r + } + + /// 32-byte signature parameter S. + public fun s(self: &GuardianSignature): Bytes32 { + self.s + } + + /// Signature recovery ID. + public fun recovery_id(self: &GuardianSignature): u8 { + self.recovery_id + } + + /// Guardian index. + public fun index(self: &GuardianSignature): u8 { + self.index + } + + /// Guardian index as u64. + public fun index_as_u64(self: &GuardianSignature): u64 { + (self.index as u64) + } + + /// Serialize elliptic curve paramters as `vector` of length == 65 to be + /// consumed by `ecdsa_k1` for public key recovery. + public fun to_rsv(gs: GuardianSignature): vector { + let GuardianSignature { r, s, recovery_id, index: _ } = gs; + let out = vector::empty(); + vector::append(&mut out, bytes32::to_bytes(r)); + vector::append(&mut out, bytes32::to_bytes(s)); + vector::push_back(&mut out, recovery_id); + out + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/emitter.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/emitter.move new file mode 100644 index 0000000000..5c5f2dbe73 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/emitter.move @@ -0,0 +1,183 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a capability (`EmitterCap`), which allows one to send +/// Wormhole messages. Its external address is determined by the capability's +/// `id`, which is a 32-byte vector. +module wormhole::emitter { + use sui::object::{Self, ID, UID}; + use sui::tx_context::{TxContext}; + + use wormhole::state::{Self, State}; + + friend wormhole::publish_message; + + /// Event reflecting when `new` is called. + struct EmitterCreated has drop, copy { + emitter_cap: ID + } + + /// Event reflecting when `destroy` is called. + struct EmitterDestroyed has drop, copy { + emitter_cap: ID + } + + /// `EmitterCap` is a Sui object that gives a user or smart contract the + /// capability to send Wormhole messages. For every Wormhole message + /// emitted, a unique `sequence` is used. + struct EmitterCap has key, store { + id: UID, + + /// Sequence number of the next wormhole message. + sequence: u64 + } + + /// Generate a new `EmitterCap`. + public fun new(wormhole_state: &State, ctx: &mut TxContext): EmitterCap { + state::assert_latest_only(wormhole_state); + + let cap = + EmitterCap { + id: object::new(ctx), + sequence: 0 + }; + + sui::event::emit( + EmitterCreated { emitter_cap: object::id(&cap)} + ); + + cap + } + + /// Returns current sequence (which will be used in the next Wormhole + /// message emitted). + public fun sequence(self: &EmitterCap): u64 { + self.sequence + } + + /// Once a Wormhole message is emitted, an `EmitterCap` upticks its + /// internal `sequence` for the next message. + public(friend) fun use_sequence(self: &mut EmitterCap): u64 { + let sequence = self.sequence; + self.sequence = sequence + 1; + sequence + } + + /// Destroys an `EmitterCap`. + /// + /// Note that this operation removes the ability to send messages using the + /// emitter id, and is irreversible. + public fun destroy(wormhole_state: &State, cap: EmitterCap) { + state::assert_latest_only(wormhole_state); + + sui::event::emit( + EmitterDestroyed { emitter_cap: object::id(&cap) } + ); + + let EmitterCap { id, sequence: _ } = cap; + object::delete(id); + } + + #[test_only] + public fun destroy_test_only(cap: EmitterCap) { + let EmitterCap { id, sequence: _ } = cap; + object::delete(id); + } + + #[test_only] + public fun dummy(): EmitterCap { + EmitterCap { + id: object::new(&mut sui::tx_context::dummy()), + sequence: 0 + } + } +} + +#[test_only] +module wormhole::emitter_tests { + use sui::object::{Self}; + use sui::test_scenario::{Self}; + + use wormhole::emitter::{Self}; + use wormhole::state::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + person, + return_state, + set_up_wormhole, + take_state + }; + + #[test] + fun test_emitter() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + + let dummy_cap = emitter::dummy(); + let expected = + @0x381dd9078c322a4663c392761a0211b527c127b29583851217f948d62131f409; + assert!(object::id_to_address(&object::id(&dummy_cap)) == expected, 0); + + // Generate new emitter. + let cap = emitter::new(&worm_state, test_scenario::ctx(scenario)); + + // And check emitter cap's address. + let expected = + @0x75c3360eb19fd2c20fbba5e2da8cf1a39cdb1ee913af3802ba330b852e459e05; + assert!(object::id_to_address(&object::id(&cap)) == expected, 0); + + // Clean up. + emitter::destroy(&worm_state, dummy_cap); + emitter::destroy(&worm_state, cap); + return_state(worm_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_new_emitter_outdated_version() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + // You shall not pass! + let cap = emitter::new(&worm_state, test_scenario::ctx(scenario)); + + // Clean up. + emitter::destroy(&worm_state, cap); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance/set_fee.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance/set_fee.move new file mode 100644 index 0000000000..ab3431b7ca --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance/set_fee.move @@ -0,0 +1,343 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact setting the +/// Wormhole message fee to another amount. +module wormhole::set_fee { + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Self}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + use wormhole::state::{Self, State}; + + /// Specific governance payload ID (action) for setting Wormhole fee. + const ACTION_SET_FEE: u8 = 3; + + struct GovernanceWitness has drop {} + + struct SetFee { + amount: u64 + } + + public fun authorize_governance( + wormhole_state: &State + ): DecreeTicket { + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(wormhole_state), + state::governance_contract(wormhole_state), + state::governance_module(), + ACTION_SET_FEE + ) + } + + /// Redeem governance VAA to configure Wormhole message fee amount in SUI + /// denomination. This governance message is only relevant for Sui because + /// fee administration is only relevant to one particular network (in this + /// case Sui). + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + public fun set_fee( + wormhole_state: &mut State, + receipt: DecreeReceipt + ): u64 { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(wormhole_state); + + let payload = + governance_message::take_payload( + state::borrow_mut_consumed_vaas(&latest_only, wormhole_state), + receipt + ); + + // Deserialize the payload as amount to change the Wormhole fee. + let SetFee { amount } = deserialize(payload); + + state::set_message_fee(&latest_only, wormhole_state, amount); + + amount + } + + fun deserialize(payload: vector): SetFee { + let cur = cursor::new(payload); + + // This amount cannot be greater than max u64. + let amount = bytes32::to_u64_be(bytes32::take_bytes(&mut cur)); + + cursor::destroy_empty(cur); + + SetFee { amount: (amount as u64) } + } + + #[test_only] + public fun action(): u8 { + ACTION_SET_FEE + } +} + +#[test_only] +module wormhole::set_fee_tests { + use sui::balance::{Self}; + use sui::test_scenario::{Self}; + + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::governance_message::{Self}; + use wormhole::set_fee::{Self}; + use wormhole::state::{Self}; + use wormhole::vaa::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + person, + return_clock, + return_state, + set_up_wormhole, + take_clock, + take_state, + upgrade_wormhole + }; + + const VAA_SET_FEE_1: vector = + x"01000000000100181aa27fd44f3060fad0ae72895d42f97c45f7a5d34aa294102911370695e91e17ae82caa59f779edde2356d95cd46c2c381cdeba7a8165901a562374f212d750000bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f7265030015000000000000000000000000000000000000000000000000000000000000015e"; + const VAA_SET_FEE_MAX: vector = + x"01000000000100b0697fd31572e11b2256cf46d5934f38fbb90e6265e999bee50950846bf9f94d5b86f247cce20e3cc158163be7b5ae21ebaaf67e20d597229ca04d505fd4bc1c0000bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f7265030015000000000000000000000000000000000000000000000000ffffffffffffffff"; + const VAA_SET_FEE_OVERFLOW: vector = + x"01000000000100950a509a797c9b40a678a5d6297f5b74e1ce1794b3c012dad5774c395e65e8b0773cf160113f571f1452ee98d10aa61273b6bc8aefa74a3c8f7e2c9c89fb25fa0000bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f72650300150000000000000000000000000000000000000000000000010000000000000000"; + + #[test] + fun test_set_fee() { + // Testing this method. + use wormhole::set_fee::{set_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 420; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Double-check current fee (from setup). + assert!(state::message_fee(&worm_state) == wormhole_fee, 0); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let fee_amount = set_fee(&mut worm_state, receipt); + assert!(wormhole_fee != fee_amount, 0); + + // Confirm the fee changed. + assert!(state::message_fee(&worm_state) == fee_amount, 0); + + // And confirm that we can deposit the new fee amount. + state::deposit_fee_test_only( + &mut worm_state, + balance::create_for_testing(fee_amount) + ); + + // Finally set the fee again to max u64 (this will effectively pause + // Wormhole message publishing until the fee gets adjusted back to a + // reasonable level again). + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_MAX, &the_clock); + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let fee_amount = set_fee(&mut worm_state, receipt); + + // Confirm. + assert!(state::message_fee(&worm_state) == fee_amount, 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_set_fee_after_upgrade() { + // Testing this method. + use wormhole::set_fee::{set_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 420; + set_up_wormhole(scenario, wormhole_fee); + + // Upgrade. + upgrade_wormhole(scenario); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Double-check current fee (from setup). + assert!(state::message_fee(&worm_state) == wormhole_fee, 0); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let fee_amount = set_fee(&mut worm_state, receipt); + + // Confirm the fee changed. + assert!(state::message_fee(&worm_state) == fee_amount, 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::set::E_KEY_ALREADY_EXISTS)] + fun test_cannot_set_fee_with_same_vaa() { + // Testing this method. + use wormhole::set_fee::{set_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 420; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Set once. + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + set_fee(&mut worm_state, receipt); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // You shall not pass! + set_fee(&mut worm_state, receipt); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::bytes32::E_U64_OVERFLOW)] + fun test_cannot_set_fee_with_overflow() { + // Testing this method. + use wormhole::set_fee::{set_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 420; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Show that the encoded fee is greater than u64 max. + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_SET_FEE_OVERFLOW, + &the_clock + ); + let payload = + governance_message::take_decree(vaa::payload(&verified_vaa)); + let cur = cursor::new(payload); + + let fee_amount = bytes::take_u256_be(&mut cur); + assert!(fee_amount > 0xffffffffffffffff, 0); + + cursor::destroy_empty(cur); + + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // You shall not pass! + set_fee(&mut worm_state, receipt); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_set_fee_outdated_version() { + // Testing this method. + use wormhole::set_fee::{set_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 420; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `set_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_SET_FEE_1, + &the_clock + ); + + let ticket = set_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // You shall not pass! + set_fee(&mut worm_state, receipt); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance/transfer_fee.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance/transfer_fee.move new file mode 100644 index 0000000000..f31274b8e0 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance/transfer_fee.move @@ -0,0 +1,529 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact transferring some +/// amount of collected fees to an intended recipient. +module wormhole::transfer_fee { + use sui::coin::{Self}; + use sui::transfer::{Self}; + use sui::tx_context::{TxContext}; + + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + use wormhole::state::{Self, State, LatestOnly}; + + /// Specific governance payload ID (action) for setting Wormhole fee. + const ACTION_TRANSFER_FEE: u8 = 4; + + struct GovernanceWitness has drop {} + + struct TransferFee { + amount: u64, + recipient: address + } + + public fun authorize_governance( + wormhole_state: &State + ): DecreeTicket { + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(wormhole_state), + state::governance_contract(wormhole_state), + state::governance_module(), + ACTION_TRANSFER_FEE + ) + } + + /// Redeem governance VAA to transfer collected Wormhole fees to the + /// recipient encoded in its Wormhole governance message. This governance + /// message is only relevant for Sui because fee administration is only + /// relevant to one particular network (in this case Sui). + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + public fun transfer_fee( + wormhole_state: &mut State, + receipt: DecreeReceipt, + ctx: &mut TxContext + ): u64 { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(wormhole_state); + + let payload = + governance_message::take_payload( + state::borrow_mut_consumed_vaas(&latest_only, wormhole_state), + receipt + ); + + // Proceed with setting the new message fee. + handle_transfer_fee(&latest_only, wormhole_state, payload, ctx) + } + + fun handle_transfer_fee( + latest_only: &LatestOnly, + wormhole_state: &mut State, + governance_payload: vector, + ctx: &mut TxContext + ): u64 { + // Deserialize the payload as amount to withdraw and to whom SUI should + // be sent. + let TransferFee { amount, recipient } = deserialize(governance_payload); + + transfer::public_transfer( + coin::from_balance( + state::withdraw_fee(latest_only, wormhole_state, amount), + ctx + ), + recipient + ); + + amount + } + + fun deserialize(payload: vector): TransferFee { + let cur = cursor::new(payload); + + // This amount cannot be greater than max u64. + let amount = bytes32::to_u64_be(bytes32::take_bytes(&mut cur)); + + // Recipient must be non-zero address. + let recipient = external_address::take_nonzero(&mut cur); + + cursor::destroy_empty(cur); + + TransferFee { + amount: (amount as u64), + recipient: external_address::to_address(recipient) + } + } + + #[test_only] + public fun action(): u8 { + ACTION_TRANSFER_FEE + } +} + +#[test_only] +module wormhole::transfer_fee_tests { + use sui::balance::{Self}; + use sui::coin::{Self, Coin}; + use sui::sui::{SUI}; + use sui::test_scenario::{Self}; + + use wormhole::bytes::{Self}; + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self}; + use wormhole::governance_message::{Self}; + use wormhole::state::{Self}; + use wormhole::transfer_fee::{Self}; + use wormhole::vaa::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + person, + return_clock, + return_state, + set_up_wormhole, + take_clock, + take_state, + two_people, + upgrade_wormhole + }; + + const VAA_TRANSFER_FEE_1: vector = + x"01000000000100a96aee105d7683266d98c9b274eddb20391378adddcefbc7a5266b4be78bc6eb582797741b65617d796c6c613ae7a4dad52a8b4aa4659842dcc4c9b3891549820100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f726504001500000000000000000000000000000000000000000000000000000000000004b0000000000000000000000000000000000000000000000000000000000000b0b2"; + const VAA_TRANSFER_FEE_OVERFLOW: vector = + x"01000000000100529b407a673f8917ccb9bb6f8d46d0f729c1ff845b0068ef5e0a3de464670b2e379a8994b15362785e52d73e01c880dbcdf432ef3702782d17d352fb07ed86830100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f72650400150000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000b0b2"; + const VAA_TRANSFER_FEE_ZERO_ADDRESS: vector = + x"0100000000010032b2ab65a690ae4af8c85903d7b22239fc272183eefdd5a4fa784664f82aa64b381380cc03859156e88623949ce4da4435199aaac1cb09e52a09d6915725a5e70100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f726504001500000000000000000000000000000000000000000000000000000000000004b00000000000000000000000000000000000000000000000000000000000000000"; + + #[test] + fun test_transfer_fee() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let (caller, recipient) = two_people(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Double-check current fee (from setup). + assert!(state::message_fee(&worm_state) == wormhole_fee, 0); + + // Deposit fee several times. + let (i, n) = (0, 8); + while (i < n) { + state::deposit_fee_test_only( + &mut worm_state, + balance::create_for_testing(wormhole_fee) + ); + i = i + 1; + }; + + // Double-check balance. + let total_deposited = n * wormhole_fee; + assert!(state::fees_collected(&worm_state) == total_deposited, 0); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_TRANSFER_FEE_1, &the_clock); + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let withdrawn = + transfer_fee( + &mut worm_state, + receipt, + test_scenario::ctx(scenario) + ); + assert!(withdrawn == 1200, 0); + + // Ignore effects. + test_scenario::next_tx(scenario, caller); + + // Verify that the recipient received the withdrawal. + let withdrawn_coin = + test_scenario::take_from_address>(scenario, recipient); + assert!(coin::value(&withdrawn_coin) == withdrawn, 0); + + // And there is still a balance on Wormhole's fee collector. + let remaining = total_deposited - withdrawn; + assert!(state::fees_collected(&worm_state) == remaining, 0); + + // Clean up. + coin::burn_for_testing(withdrawn_coin); + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_transfer_fee_after_upgrade() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Upgrade. + upgrade_wormhole(scenario); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Double-check current fee (from setup). + assert!(state::message_fee(&worm_state) == wormhole_fee, 0); + + // Deposit fee several times. + let (i, n) = (0, 8); + while (i < n) { + state::deposit_fee_test_only( + &mut worm_state, + balance::create_for_testing(wormhole_fee) + ); + i = i + 1; + }; + + // Double-check balance. + let total_deposited = n * wormhole_fee; + assert!(state::fees_collected(&worm_state) == total_deposited, 0); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_TRANSFER_FEE_1, &the_clock); + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let withdrawn = + transfer_fee( + &mut worm_state, + receipt, + test_scenario::ctx(scenario) + ); + assert!(withdrawn == 1200, 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::set::E_KEY_ALREADY_EXISTS)] + fun test_cannot_transfer_fee_with_same_vaa() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Double-check current fee (from setup). + assert!(state::message_fee(&worm_state) == wormhole_fee, 0); + + // Deposit fee several times. + let (i, n) = (0, 8); + while (i < n) { + state::deposit_fee_test_only( + &mut worm_state, + balance::create_for_testing(wormhole_fee) + ); + i = i + 1; + }; + + // Transfer once. + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_TRANSFER_FEE_1, &the_clock); + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + transfer_fee(&mut worm_state, receipt, test_scenario::ctx(scenario)); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_TRANSFER_FEE_1, &the_clock); + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + transfer_fee(&mut worm_state, receipt, test_scenario::ctx(scenario)); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = sui::balance::ENotEnough)] + fun test_cannot_transfer_fee_insufficient_balance() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Show balance is zero. + assert!(state::fees_collected(&worm_state) == 0, 0); + + // Show that the encoded fee is greater than zero. + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_TRANSFER_FEE_1, &the_clock); + let payload = + governance_message::take_decree(vaa::payload(&verified_vaa)); + let cur = cursor::new(payload); + + let amount = bytes::take_u256_be(&mut cur); + assert!(amount > 0, 0); + cursor::take_rest(cur); + + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + transfer_fee(&mut worm_state, receipt, test_scenario::ctx(scenario)); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = external_address::E_ZERO_ADDRESS)] + fun test_cannot_transfer_fee_recipient_zero_address() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Show balance is zero. + assert!(state::fees_collected(&worm_state) == 0, 0); + + // Show that the encoded fee is greater than zero. + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_TRANSFER_FEE_ZERO_ADDRESS, + &the_clock + ); + let payload = + governance_message::take_decree(vaa::payload(&verified_vaa)); + let cur = cursor::new(payload); + + bytes::take_u256_be(&mut cur); + + // Confirm recipient is zero address. + let addr = bytes32::take_bytes(&mut cur); + assert!(!bytes32::is_nonzero(&addr), 0); + cursor::destroy_empty(cur); + + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + transfer_fee(&mut worm_state, receipt, test_scenario::ctx(scenario)); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::bytes32::E_U64_OVERFLOW)] + fun test_cannot_transfer_fee_withdraw_amount_overflow() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Show balance is zero. + assert!(state::fees_collected(&worm_state) == 0, 0); + + // Show that the encoded fee is greater than zero. + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_TRANSFER_FEE_OVERFLOW, + &the_clock + ); + let payload = + governance_message::take_decree(vaa::payload(&verified_vaa)); + let cur = cursor::new(payload); + + let amount = bytes::take_u256_be(&mut cur); + assert!(amount > 0xffffffffffffffff, 0); + cursor::take_rest(cur); + + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + transfer_fee(&mut worm_state, receipt, test_scenario::ctx(scenario)); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_set_fee_outdated_version() { + // Testing this method. + use wormhole::transfer_fee::{transfer_fee}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Double-check current fee (from setup). + assert!(state::message_fee(&worm_state) == wormhole_fee, 0); + + // Deposit fee several times. + let (i, n) = (0, 8); + while (i < n) { + state::deposit_fee_test_only( + &mut worm_state, + balance::create_for_testing(wormhole_fee) + ); + i = i + 1; + }; + + // Double-check balance. + let total_deposited = n * wormhole_fee; + assert!(state::fees_collected(&worm_state) == total_deposited, 0); + + // Prepare test to execute `transfer_fee`. + test_scenario::next_tx(scenario, caller); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_TRANSFER_FEE_1, + &the_clock + ); + let ticket = transfer_fee::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + transfer_fee(&mut worm_state, receipt, test_scenario::ctx(scenario)); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance/update_guardian_set.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance/update_guardian_set.move new file mode 100644 index 0000000000..15bfb1953b --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance/update_guardian_set.move @@ -0,0 +1,471 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact updating the +/// current guardian set to be a new set of guardian public keys. As a part of +/// this process, the previous guardian set's expiration time is set. Keep in +/// mind that the current guardian set has no expiration. +module wormhole::update_guardian_set { + use std::vector::{Self}; + use sui::clock::{Clock}; + + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + use wormhole::guardian::{Self, Guardian}; + use wormhole::guardian_set::{Self}; + use wormhole::state::{Self, State, LatestOnly}; + + /// No guardians public keys found in VAA. + const E_NO_GUARDIANS: u64 = 0; + /// Guardian set index is not incremented from last known guardian set. + const E_NON_INCREMENTAL_GUARDIAN_SETS: u64 = 1; + + /// Specific governance payload ID (action) for updating the guardian set. + const ACTION_UPDATE_GUARDIAN_SET: u8 = 2; + + struct GovernanceWitness has drop {} + + /// Event reflecting a Guardian Set update. + struct GuardianSetAdded has drop, copy { + new_index: u32 + } + + struct UpdateGuardianSet { + new_index: u32, + guardians: vector, + } + + public fun authorize_governance( + wormhole_state: &State + ): DecreeTicket { + governance_message::authorize_verify_global( + GovernanceWitness {}, + state::governance_chain(wormhole_state), + state::governance_contract(wormhole_state), + state::governance_module(), + ACTION_UPDATE_GUARDIAN_SET + ) + } + + /// Redeem governance VAA to update the current Guardian set with a new + /// set of Guardian public keys. This governance action is applied globally + /// across all networks. + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + public fun update_guardian_set( + wormhole_state: &mut State, + receipt: DecreeReceipt, + the_clock: &Clock + ): u32 { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(wormhole_state); + + // Even though this disallows the VAA to be replayed, it may be + // impossible to redeem the same VAA again because `governance_message` + // requires new governance VAAs being signed by the most recent guardian + // set). + let payload = + governance_message::take_payload( + state::borrow_mut_consumed_vaas(&latest_only, wormhole_state), + receipt + ); + + // Proceed with the update. + handle_update_guardian_set(&latest_only, wormhole_state, payload, the_clock) + } + + fun handle_update_guardian_set( + latest_only: &LatestOnly, + wormhole_state: &mut State, + governance_payload: vector, + the_clock: &Clock + ): u32 { + // Deserialize the payload as the updated guardian set. + let UpdateGuardianSet { + new_index, + guardians + } = deserialize(governance_payload); + + // Every new guardian set index must be incremental from the last known + // guardian set. + assert!( + new_index == state::guardian_set_index(wormhole_state) + 1, + E_NON_INCREMENTAL_GUARDIAN_SETS + ); + + // Expire the existing guardian set. + state::expire_guardian_set(latest_only, wormhole_state, the_clock); + + // And store the new one. + state::add_new_guardian_set( + latest_only, + wormhole_state, + guardian_set::new(new_index, guardians) + ); + + sui::event::emit(GuardianSetAdded { new_index }); + + new_index + } + + fun deserialize(payload: vector): UpdateGuardianSet { + let cur = cursor::new(payload); + let new_index = bytes::take_u32_be(&mut cur); + let num_guardians = bytes::take_u8(&mut cur); + assert!(num_guardians > 0, E_NO_GUARDIANS); + + let guardians = vector::empty(); + let i = 0; + while (i < num_guardians) { + let key = bytes::take_bytes(&mut cur, 20); + vector::push_back(&mut guardians, guardian::new(key)); + i = i + 1; + }; + cursor::destroy_empty(cur); + + UpdateGuardianSet { new_index, guardians } + } + + #[test_only] + public fun action(): u8 { + ACTION_UPDATE_GUARDIAN_SET + } +} + +#[test_only] +module wormhole::update_guardian_set_tests { + use std::vector::{Self}; + use sui::clock::{Self}; + use sui::test_scenario::{Self}; + + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + use wormhole::governance_message::{Self}; + use wormhole::guardian::{Self}; + use wormhole::guardian_set::{Self}; + use wormhole::state::{Self}; + use wormhole::update_guardian_set::{Self}; + use wormhole::vaa::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + person, + return_clock, + return_state, + set_up_wormhole, + take_clock, + take_state, + upgrade_wormhole + }; + + const VAA_UPDATE_GUARDIAN_SET_1: vector = + x"010000000001004f74e9596bd8246ef456918594ae16e81365b52c0cf4490b2a029fb101b058311f4a5592baeac014dc58215faad36453467a85a4c3e1c6cf5166e80f6e4dc50b0100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f72650200000000000113befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe88d7d8b32a9105d228100e72dffe2fae0705d31c58076f561cc62a47087b567c86f986426dfcd000bd6e9833490f8fa87c733a183cd076a6cbd29074b853fcf0a5c78c1b56d15fce7a154e6ebe9ed7a2af3503dbd2e37518ab04d7ce78b630f98b15b78a785632dea5609064803b1c8ea8bb2c77a6004bd109a281a698c0f5ba31f158585b41f4f33659e54d3178443ab76a60e21690dbfb17f7f59f09ae3ea1647ec26ae49b14060660504f4da1c2059e1c5ab6810ac3d8e1258bd2f004a94ca0cd4c68fc1c061180610e96d645b12f47ae5cf4546b18538739e90f2edb0d8530e31a218e72b9480202acbaeb06178da78858e5e5c4705cdd4b668ffe3be5bae4867c9d5efe3a05efc62d60e1d19faeb56a80223cdd3472d791b7d32c05abb1cc00b6381fa0c4928f0c56fc14bc029b8809069093d712a3fd4dfab31963597e246ab29fc6ebedf2d392a51ab2dc5c59d0902a03132a84dfd920b35a3d0ba5f7a0635df298f9033e"; + const VAA_UPDATE_GUARDIAN_SET_2A: vector = + x"010000000001005fb17d5e0e736e3014756bf7e7335722c4fe3ad18b5b1b566e8e61e562cc44555f30b298bc6a21ea4b192a6f1877a5e638ecf90a77b0b028f297a3a70d93614d0100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f72650200000000000101befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe"; + const VAA_UPDATE_GUARDIAN_SET_2B: vector = + x"01000000010100195f37abd29438c74db6e57bf527646b36fa96e36392221e869debe0e911f2f319abc0fd5c5a454da76fc0ffdd23a71a60bca40aa4289a841ad07f2964cde9290000bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000020100000000000000000000000000000000000000000000000000000000436f72650200000000000201befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe"; + const VAA_UPDATE_GUARDIAN_SET_EMPTY: vector = + x"0100000000010098f9e45f836661d2932def9c74c587168f4f75d0282201ee6f5a98557e6212ff19b0f8881c2750646250f60dd5d565530779ecbf9442aa5ffc2d6afd7303aaa40000bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f72650200000000000100"; + + #[test] + fun test_update_guardian_set() { + // Testing this method. + use wormhole::update_guardian_set::{update_guardian_set}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `update_guardian_set`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_1, + &the_clock + ); + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let new_index = + update_guardian_set(&mut worm_state, receipt, &the_clock); + assert!(new_index == 1, 0); + + let new_guardian_set = + state::guardian_set_at(&worm_state, new_index); + + // Verify new guardian set index. + assert!(state::guardian_set_index(&worm_state) == new_index, 0); + assert!( + guardian_set::index(new_guardian_set) == state::guardian_set_index(&worm_state), + 0 + ); + + // Check that the guardians agree with what we expect. + let guardians = guardian_set::guardians(new_guardian_set); + let expected = vector[ + guardian::new(x"befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe"), + guardian::new(x"88d7d8b32a9105d228100e72dffe2fae0705d31c"), + guardian::new(x"58076f561cc62a47087b567c86f986426dfcd000"), + guardian::new(x"bd6e9833490f8fa87c733a183cd076a6cbd29074"), + guardian::new(x"b853fcf0a5c78c1b56d15fce7a154e6ebe9ed7a2"), + guardian::new(x"af3503dbd2e37518ab04d7ce78b630f98b15b78a"), + guardian::new(x"785632dea5609064803b1c8ea8bb2c77a6004bd1"), + guardian::new(x"09a281a698c0f5ba31f158585b41f4f33659e54d"), + guardian::new(x"3178443ab76a60e21690dbfb17f7f59f09ae3ea1"), + guardian::new(x"647ec26ae49b14060660504f4da1c2059e1c5ab6"), + guardian::new(x"810ac3d8e1258bd2f004a94ca0cd4c68fc1c0611"), + guardian::new(x"80610e96d645b12f47ae5cf4546b18538739e90f"), + guardian::new(x"2edb0d8530e31a218e72b9480202acbaeb06178d"), + guardian::new(x"a78858e5e5c4705cdd4b668ffe3be5bae4867c9d"), + guardian::new(x"5efe3a05efc62d60e1d19faeb56a80223cdd3472"), + guardian::new(x"d791b7d32c05abb1cc00b6381fa0c4928f0c56fc"), + guardian::new(x"14bc029b8809069093d712a3fd4dfab31963597e"), + guardian::new(x"246ab29fc6ebedf2d392a51ab2dc5c59d0902a03"), + guardian::new(x"132a84dfd920b35a3d0ba5f7a0635df298f9033e"), + ]; + assert!(vector::length(&expected) == vector::length(guardians), 0); + + let cur = cursor::new(expected); + let i = 0; + while (!cursor::is_empty(&cur)) { + let left = guardian::as_bytes(vector::borrow(guardians, i)); + let right = guardian::to_bytes(cursor::poke(&mut cur)); + assert!(left == right, 0); + i = i + 1; + }; + cursor::destroy_empty(cur); + + // Make sure old guardian set is still active. + let old_guardian_set = + state::guardian_set_at(&worm_state, new_index - 1); + assert!(guardian_set::is_active(old_guardian_set, &the_clock), 0); + + // Fast forward time beyond expiration by + // `guardian_set_seconds_to_live`. + let tick_ms = + (state::guardian_set_seconds_to_live(&worm_state) as u64) * 1000; + clock::increment_for_testing(&mut the_clock, tick_ms + 1); + + // Now the old guardian set should be expired (because in the test setup + // time to live is set to 2 epochs). + assert!(!guardian_set::is_active(old_guardian_set, &the_clock), 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_update_guardian_set_after_upgrade() { + // Testing this method. + use wormhole::update_guardian_set::{update_guardian_set}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Upgrade. + upgrade_wormhole(scenario); + + // Prepare test to execute `update_guardian_set`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_1, + &the_clock + ); + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let new_index = + update_guardian_set(&mut worm_state, receipt, &the_clock); + assert!(new_index == 1, 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_OLD_GUARDIAN_SET_GOVERNANCE + )] + fun test_cannot_update_guardian_set_again_with_same_vaa() { + // Testing this method. + use wormhole::update_guardian_set::{update_guardian_set}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `update_guardian_set`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_2A, + &the_clock + ); + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + update_guardian_set(&mut worm_state, receipt, &the_clock); + + // Update guardian set again with new VAA. + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_2B, + &the_clock + ); + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + let new_index = + update_guardian_set(&mut worm_state, receipt, &the_clock); + assert!(new_index == 2, 0); + assert!(state::guardian_set_index(&worm_state) == 2, 0); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_2A, + &the_clock + ); + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + update_guardian_set(&mut worm_state, receipt, &the_clock); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = update_guardian_set::E_NO_GUARDIANS)] + fun test_cannot_update_guardian_set_with_no_guardians() { + // Testing this method. + use wormhole::update_guardian_set::{update_guardian_set}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `update_guardian_set`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + + // Show that the encoded number of guardians is zero. + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_EMPTY, + &the_clock + ); + let payload = + governance_message::take_decree(vaa::payload(&verified_vaa)); + let cur = cursor::new(payload); + + let new_guardian_set_index = bytes::take_u32_be(&mut cur); + assert!(new_guardian_set_index == 1, 0); + + let num_guardians = bytes::take_u8(&mut cur); + assert!(num_guardians == 0, 0); + + cursor::destroy_empty(cur); + + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + update_guardian_set(&mut worm_state, receipt, &the_clock); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_set_fee_outdated_version() { + // Testing this method. + use wormhole::update_guardian_set::{update_guardian_set}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test to execute `update_guardian_set`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_1, + &the_clock + ); + let ticket = update_guardian_set::authorize_governance(&worm_state); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + // You shall not pass! + update_guardian_set(&mut worm_state, receipt, &the_clock); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance/upgrade_contract.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance/upgrade_contract.move new file mode 100644 index 0000000000..018511e784 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance/upgrade_contract.move @@ -0,0 +1,126 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements handling a governance VAA to enact upgrading the +/// Wormhole contract to a new build. The procedure to upgrade this contract +/// requires a Programmable Transaction, which includes the following procedure: +/// 1. Load new build. +/// 2. Authorize upgrade. +/// 3. Upgrade. +/// 4. Commit upgrade. +module wormhole::upgrade_contract { + use sui::object::{ID}; + use sui::package::{UpgradeReceipt, UpgradeTicket}; + + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::cursor::{Self}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + use wormhole::state::{Self, State}; + + friend wormhole::migrate; + + /// Digest is all zeros. + const E_DIGEST_ZERO_BYTES: u64 = 0; + + /// Specific governance payload ID (action) to complete upgrading the + /// contract. + const ACTION_UPGRADE_CONTRACT: u8 = 1; + + struct GovernanceWitness has drop {} + + // Event reflecting package upgrade. + struct ContractUpgraded has drop, copy { + old_contract: ID, + new_contract: ID + } + + struct UpgradeContract { + digest: Bytes32 + } + + public fun authorize_governance( + wormhole_state: &State + ): DecreeTicket { + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(wormhole_state), + state::governance_contract(wormhole_state), + state::governance_module(), + ACTION_UPGRADE_CONTRACT + ) + } + + /// Redeem governance VAA to issue an `UpgradeTicket` for the upgrade given + /// a contract upgrade VAA. This governance message is only relevant for Sui + /// because a contract upgrade is only relevant to one particular network + /// (in this case Sui), whose build digest is encoded in this message. + public fun authorize_upgrade( + wormhole_state: &mut State, + receipt: DecreeReceipt + ): UpgradeTicket { + // NOTE: This is the only governance method that does not enforce + // current package checking when consuming VAA hashes. This is because + // upgrades are protected by the Sui VM, enforcing the latest package + // is the one performing the upgrade. + let consumed = + state::borrow_mut_consumed_vaas_unchecked(wormhole_state); + + // And consume. + let payload = governance_message::take_payload(consumed, receipt); + + // Proceed with processing new implementation version. + handle_upgrade_contract(wormhole_state, payload) + } + + /// Finalize the upgrade that ran to produce the given `receipt`. This + /// method invokes `state::commit_upgrade` which interacts with + /// `sui::package`. + public fun commit_upgrade( + self: &mut State, + receipt: UpgradeReceipt, + ) { + let (old_contract, new_contract) = state::commit_upgrade(self, receipt); + + // Emit an event reflecting package ID change. + sui::event::emit(ContractUpgraded { old_contract, new_contract }); + } + + /// Privileged method only to be used by this module and `migrate` module. + /// + /// During migration, we make sure that the digest equals what we expect by + /// passing in the same VAA used to upgrade the package. + public(friend) fun take_digest(governance_payload: vector): Bytes32 { + // Deserialize the payload as the build digest. + let UpgradeContract { digest } = deserialize(governance_payload); + + digest + } + + fun handle_upgrade_contract( + wormhole_state: &mut State, + payload: vector + ): UpgradeTicket { + state::authorize_upgrade(wormhole_state, take_digest(payload)) + } + + fun deserialize(payload: vector): UpgradeContract { + let cur = cursor::new(payload); + + // This amount cannot be greater than max u64. + let digest = bytes32::take_bytes(&mut cur); + assert!(bytes32::is_nonzero(&digest), E_DIGEST_ZERO_BYTES); + + cursor::destroy_empty(cur); + + UpgradeContract { digest } + } + + #[test_only] + public fun action(): u8 { + ACTION_UPGRADE_CONTRACT + } +} + +#[test_only] +module wormhole::upgrade_contract_tests { + // TODO +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance_message.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance_message.move new file mode 100644 index 0000000000..20d4cfee5f --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/governance_message.move @@ -0,0 +1,694 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type representing a Guardian governance +/// action. Each governance action has an associated module name, relevant chain +/// and payload encoding instructions/data used to perform an administrative +/// change on a contract. +module wormhole::governance_message { + use wormhole::bytes::{Self}; + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::consumed_vaas::{Self, ConsumedVAAs}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{ExternalAddress}; + use wormhole::state::{Self, State, chain_id}; + use wormhole::vaa::{Self, VAA}; + + /// Guardian set used to sign VAA did not use current Guardian set. + const E_OLD_GUARDIAN_SET_GOVERNANCE: u64 = 0; + /// Governance chain does not match. + const E_INVALID_GOVERNANCE_CHAIN: u64 = 1; + /// Governance emitter address does not match. + const E_INVALID_GOVERNANCE_EMITTER: u64 = 2; + /// Governance module name does not match. + const E_INVALID_GOVERNANCE_MODULE: u64 = 4; + /// Governance action does not match. + const E_INVALID_GOVERNANCE_ACTION: u64 = 5; + /// Governance target chain not indicative of global action. + const E_GOVERNANCE_TARGET_CHAIN_NONZERO: u64 = 6; + /// Governance target chain not indicative of actino specifically for Sui + /// Wormhole contract. + const E_GOVERNANCE_TARGET_CHAIN_NOT_SUI: u64 = 7; + + /// The public constructors for `DecreeTicket` (`authorize_verify_global` + /// and `authorize_verify_local`) require a witness of type `T`. This is to + /// ensure that `DecreeTicket`s cannot be mixed up between modules + /// maliciously. + struct DecreeTicket { + governance_chain: u16, + governance_contract: ExternalAddress, + module_name: Bytes32, + action: u8, + global: bool + } + + struct DecreeReceipt { + payload: vector, + digest: Bytes32, + sequence: u64 + } + + /// This method prepares `DecreeTicket` for global governance action. This + /// means the VAA encodes target chain ID == 0. + public fun authorize_verify_global( + _witness: T, + governance_chain: u16, + governance_contract: ExternalAddress, + module_name: Bytes32, + action: u8 + ): DecreeTicket { + DecreeTicket { + governance_chain, + governance_contract, + module_name, + action, + global: true + } + } + + /// This method prepares `DecreeTicket` for local governance action. This + /// means the VAA encodes target chain ID == 21 (Sui's). + public fun authorize_verify_local( + _witness: T, + governance_chain: u16, + governance_contract: ExternalAddress, + module_name: Bytes32, + action: u8 + ): DecreeTicket { + DecreeTicket { + governance_chain, + governance_contract, + module_name, + action, + global: false + } + } + + public fun sequence(receipt: &DecreeReceipt): u64 { + receipt.sequence + } + + /// This method unpacks `DecreeReceipt` and puts the VAA digest into a + /// `ConsumedVAAs` container. Then it returns the governance payload. + public fun take_payload( + consumed: &mut ConsumedVAAs, + receipt: DecreeReceipt + ): vector { + let DecreeReceipt { payload, digest, sequence: _ } = receipt; + + consumed_vaas::consume(consumed, digest); + + payload + } + + /// Method to peek into the payload in `DecreeReceipt`. + public fun payload(receipt: &DecreeReceipt): vector { + receipt.payload + } + + /// Destroy the receipt. + public fun destroy(receipt: DecreeReceipt) { + let DecreeReceipt { payload: _, digest: _, sequence: _ } = receipt; + } + + /// This method unpacks a `DecreeTicket` to validate its members to make + /// sure that the parameters match what was encoded in the VAA. + public fun verify_vaa( + wormhole_state: &State, + verified_vaa: VAA, + ticket: DecreeTicket + ): DecreeReceipt { + state::assert_latest_only(wormhole_state); + + let DecreeTicket { + governance_chain, + governance_contract, + module_name, + action, + global + } = ticket; + + // Protect against governance actions enacted using an old guardian set. + // This is not a protection found in the other Wormhole contracts. + assert!( + vaa::guardian_set_index(&verified_vaa) == state::guardian_set_index(wormhole_state), + E_OLD_GUARDIAN_SET_GOVERNANCE + ); + + // Both the emitter chain and address must equal. + assert!( + vaa::emitter_chain(&verified_vaa) == governance_chain, + E_INVALID_GOVERNANCE_CHAIN + ); + assert!( + vaa::emitter_address(&verified_vaa) == governance_contract, + E_INVALID_GOVERNANCE_EMITTER + ); + + // Cache VAA digest. + let digest = vaa::digest(&verified_vaa); + + // Get the VAA sequence number. + let sequence = vaa::sequence(&verified_vaa); + + // Finally deserialize Wormhole payload as governance message. + let ( + parsed_module_name, + parsed_action, + chain, + payload + ) = deserialize(vaa::take_payload(verified_vaa)); + + assert!(module_name == parsed_module_name, E_INVALID_GOVERNANCE_MODULE); + assert!(action == parsed_action, E_INVALID_GOVERNANCE_ACTION); + + // Target chain, which determines whether the governance VAA applies to + // all chains or Sui. + if (global) { + assert!(chain == 0, E_GOVERNANCE_TARGET_CHAIN_NONZERO); + } else { + assert!(chain == chain_id(), E_GOVERNANCE_TARGET_CHAIN_NOT_SUI); + }; + + DecreeReceipt { payload, digest, sequence } + } + + fun deserialize(buf: vector): (Bytes32, u8, u16, vector) { + let cur = cursor::new(buf); + + ( + bytes32::take_bytes(&mut cur), + bytes::take_u8(&mut cur), + bytes::take_u16_be(&mut cur), + cursor::take_rest(cur) + ) + } + + #[test_only] + public fun deserialize_test_only( + buf: vector + ): ( + Bytes32, + u8, + u16, + vector + ) { + deserialize(buf) + } + + #[test_only] + public fun take_decree(buf: vector): vector { + let (_, _, _, payload) = deserialize(buf); + payload + } +} + +#[test_only] +module wormhole::governance_message_tests { + use sui::test_scenario::{Self}; + use sui::tx_context::{Self}; + + use wormhole::bytes32::{Self}; + use wormhole::consumed_vaas::{Self}; + use wormhole::external_address::{Self}; + use wormhole::governance_message::{Self}; + use wormhole::state::{Self}; + use wormhole::vaa::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + set_up_wormhole, + person, + return_clock, + return_state, + take_clock, + take_state + }; + + struct GovernanceWitness has drop {} + + const VAA_UPDATE_GUARDIAN_SET_1: vector = + x"010000000001004f74e9596bd8246ef456918594ae16e81365b52c0cf4490b2a029fb101b058311f4a5592baeac014dc58215faad36453467a85a4c3e1c6cf5166e80f6e4dc50b0100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f72650200000000000113befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe88d7d8b32a9105d228100e72dffe2fae0705d31c58076f561cc62a47087b567c86f986426dfcd000bd6e9833490f8fa87c733a183cd076a6cbd29074b853fcf0a5c78c1b56d15fce7a154e6ebe9ed7a2af3503dbd2e37518ab04d7ce78b630f98b15b78a785632dea5609064803b1c8ea8bb2c77a6004bd109a281a698c0f5ba31f158585b41f4f33659e54d3178443ab76a60e21690dbfb17f7f59f09ae3ea1647ec26ae49b14060660504f4da1c2059e1c5ab6810ac3d8e1258bd2f004a94ca0cd4c68fc1c061180610e96d645b12f47ae5cf4546b18538739e90f2edb0d8530e31a218e72b9480202acbaeb06178da78858e5e5c4705cdd4b668ffe3be5bae4867c9d5efe3a05efc62d60e1d19faeb56a80223cdd3472d791b7d32c05abb1cc00b6381fa0c4928f0c56fc14bc029b8809069093d712a3fd4dfab31963597e246ab29fc6ebedf2d392a51ab2dc5c59d0902a03132a84dfd920b35a3d0ba5f7a0635df298f9033e"; + const VAA_SET_FEE_1: vector = + x"01000000000100181aa27fd44f3060fad0ae72895d42f97c45f7a5d34aa294102911370695e91e17ae82caa59f779edde2356d95cd46c2c381cdeba7a8165901a562374f212d750000bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f7265030015000000000000000000000000000000000000000000000000000000000000015e"; + + #[test] + fun test_global_action() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_1, + &the_clock + ); + let ( + _, + _, + _, + expected_payload + ) = governance_message::deserialize_test_only( + vaa::payload(&verified_vaa) + ); + + let ticket = + governance_message::authorize_verify_global( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + state::governance_module(), + 2 // update guadian set + ); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + let consumed = consumed_vaas::new(&mut tx_context::dummy()); + let payload = governance_message::take_payload(&mut consumed, receipt); + assert!(payload == expected_payload, 0); + + // Clean up. + consumed_vaas::destroy(consumed); + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_local_action() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ( + _, + _, + _, + expected_payload + ) = governance_message::deserialize_test_only( + vaa::payload(&verified_vaa) + ); + + let ticket = + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + state::governance_module(), + 3 // set fee + ); + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + let consumed = consumed_vaas::new(&mut tx_context::dummy()); + let payload = governance_message::take_payload(&mut consumed, receipt); + assert!(payload == expected_payload, 0); + + // Clean up. + consumed_vaas::destroy(consumed); + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_INVALID_GOVERNANCE_CHAIN + )] + fun test_cannot_verify_vaa_invalid_governance_chain() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + + // Show that this emitter chain ID does not equal the encoded one. + let invalid_chain = 0xffff; + assert!(invalid_chain != vaa::emitter_chain(&verified_vaa), 0); + + let ticket = + governance_message::authorize_verify_local( + GovernanceWitness {}, + invalid_chain, + state::governance_contract(&worm_state), + state::governance_module(), + 3 // set fee + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_INVALID_GOVERNANCE_EMITTER + )] + fun test_cannot_verify_vaa_invalid_governance_emitter() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + + // Show that this emitter address does not equal the encoded one. + let invalid_emitter = external_address::new(bytes32::default()); + assert!(invalid_emitter != vaa::emitter_address(&verified_vaa), 0); + + let ticket = + governance_message::authorize_verify_global( + GovernanceWitness {}, + state::governance_chain(&worm_state), + invalid_emitter, + state::governance_module(), + 3 // set fee + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_INVALID_GOVERNANCE_MODULE + )] + fun test_cannot_verify_vaa_invalid_governance_module() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ( + expected_module, + _, + _, + _ + ) = governance_message::deserialize_test_only( + vaa::payload(&verified_vaa) + ); + + // Show that this module does not equal the encoded one. + let invalid_module = bytes32::from_bytes(b"Not Wormhole"); + assert!(invalid_module != expected_module, 0); + + let ticket = + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + invalid_module, + 3 // set fee + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_INVALID_GOVERNANCE_ACTION + )] + fun test_cannot_verify_vaa_invalid_governance_action() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ( + _, + expected_action, + _, + _ + ) = governance_message::deserialize_test_only( + vaa::payload(&verified_vaa) + ); + + // Show that this action does not equal the encoded one. + let invalid_action = 0xff; + assert!(invalid_action != expected_action, 0); + + let ticket = + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + state::governance_module(), + invalid_action + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_GOVERNANCE_TARGET_CHAIN_NONZERO + )] + fun test_cannot_verify_vaa_governance_target_chain_nonzero() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ( + _, + _, + expected_target_chain, + _ + ) = governance_message::deserialize_test_only( + vaa::payload(&verified_vaa) + ); + + // Show that this target chain ID does reflect a global action. + let not_global = expected_target_chain != 0; + assert!(not_global, 0); + + let ticket = + governance_message::authorize_verify_global( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + state::governance_module(), + 3 // set fee + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } + + #[test] + #[expected_failure( + abort_code = governance_message::E_GOVERNANCE_TARGET_CHAIN_NOT_SUI + )] + fun test_cannot_verify_vaa_governance_target_chain_not_sui() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify( + &worm_state, + VAA_UPDATE_GUARDIAN_SET_1, + &the_clock + ); + let ( + _, + _, + expected_target_chain, + _ + ) = governance_message::deserialize_test_only( + vaa::payload(&verified_vaa) + ); + + // Show that this target chain ID does reflect a global action. + let global = expected_target_chain == 0; + assert!(global, 0); + + let ticket = + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + state::governance_module(), + 2 // update guardian set + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_verify_vaa_outdated_version() { + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + let wormhole_fee = 350; + set_up_wormhole(scenario, wormhole_fee); + + // Prepare test setting sender to `caller`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = + vaa::parse_and_verify(&worm_state, VAA_SET_FEE_1, &the_clock); + let ticket = + governance_message::authorize_verify_local( + GovernanceWitness {}, + state::governance_chain(&worm_state), + state::governance_contract(&worm_state), + state::governance_module(), + 3 // set fee + ); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + // You shall not pass! + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + governance_message::destroy(receipt); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/migrate.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/migrate.move new file mode 100644 index 0000000000..958a0b12f8 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/migrate.move @@ -0,0 +1,220 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a public method intended to be called after an +/// upgrade has been committed. The purpose is to add one-off migration logic +/// that would alter Wormhole `State`. +/// +/// Included in migration is the ability to ensure that breaking changes for +/// any of Wormhole's methods by enforcing the current build version as their +/// required minimum version. +module wormhole::migrate { + use sui::clock::{Clock}; + use sui::object::{ID}; + + use wormhole::governance_message::{Self}; + use wormhole::state::{Self, State}; + use wormhole::upgrade_contract::{Self}; + use wormhole::vaa::{Self}; + + /// Event reflecting when `migrate` is successfully executed. + struct MigrateComplete has drop, copy { + package: ID + } + + /// Execute migration logic. See `wormhole::migrate` description for more + /// info. + public fun migrate( + wormhole_state: &mut State, + upgrade_vaa_buf: vector, + the_clock: &Clock + ) { + state::migrate__v__0_2_0(wormhole_state); + + // Perform standard migrate. + handle_migrate(wormhole_state, upgrade_vaa_buf, the_clock); + + //////////////////////////////////////////////////////////////////////// + // + // NOTE: Put any one-off migration logic here. + // + // Most upgrades likely won't need to do anything, in which case the + // rest of this function's body may be empty. Make sure to delete it + // after the migration has gone through successfully. + // + // WARNING: The migration does *not* proceed atomically with the + // upgrade (as they are done in separate transactions). + // If the nature of this migration absolutely requires the migration to + // happen before certain other functionality is available, then guard + // that functionality with the `assert!` from above. + // + //////////////////////////////////////////////////////////////////////// + + //////////////////////////////////////////////////////////////////////// + } + + fun handle_migrate( + wormhole_state: &mut State, + upgrade_vaa_buf: vector, + the_clock: &Clock + ) { + // Update the version first. + // + // See `version_control` module for hard-coded configuration. + state::migrate_version(wormhole_state); + + // This VAA needs to have been used for upgrading this package. + // + // NOTE: All of the following methods have protections to make sure that + // the current build is used. Given that we officially migrated the + // version as the first call of `migrate`, these should be successful. + + // First we need to check that `parse_and_verify` still works. + let verified_vaa = + vaa::parse_and_verify(wormhole_state, upgrade_vaa_buf, the_clock); + + // And governance methods. + let ticket = upgrade_contract::authorize_governance(wormhole_state); + let receipt = + governance_message::verify_vaa( + wormhole_state, + verified_vaa, + ticket + ); + + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(wormhole_state); + + // Check if build digest is the current one. + let digest = + upgrade_contract::take_digest( + governance_message::payload(&receipt) + ); + state::assert_authorized_digest(&latest_only, wormhole_state, digest); + governance_message::destroy(receipt); + + // Finally emit an event reflecting a successful migrate. + let package = state::current_package(&latest_only, wormhole_state); + sui::event::emit(MigrateComplete { package }); + } + + #[test_only] + public fun set_up_migrate(wormhole_state: &mut State) { + state::reverse_migrate__v__dummy(wormhole_state); + } +} + +#[test_only] +module wormhole::migrate_tests { + use sui::test_scenario::{Self}; + + use wormhole::state::{Self}; + use wormhole::wormhole_scenario::{ + person, + return_clock, + return_state, + set_up_wormhole, + take_clock, + take_state, + upgrade_wormhole + }; + + const UPGRADE_VAA: vector = + x"01000000000100db695668c0c91f4df6e4106dcb912d9062898fd976d631ff1c1b4109ccd203b43cd2419c7d9a191f8d42a780419e63307aacc93080d8629c6c03061c52becf1d0100bc614e000000000001000000000000000000000000000000000000000000000000000000000000000400000000000000010100000000000000000000000000000000000000000000000000000000436f726501001500000000000000000000000000000000000000000000006e6577206275696c64"; + + #[test] + fun test_migrate() { + use wormhole::migrate::{migrate}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole. + let wormhole_message_fee = 350; + set_up_wormhole(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + // Upgrade (digest is just b"new build") for testing purposes. + upgrade_wormhole(scenario); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Set up migrate (which prepares this package to be the same state as + // a previous release). + wormhole::migrate::set_up_migrate(&mut worm_state); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + migrate(&mut worm_state, UPGRADE_VAA, &the_clock); + + // Make sure we emitted an event. + let effects = test_scenario::next_tx(scenario, user); + assert!(test_scenario::num_user_events(&effects) == 1, 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_INCORRECT_OLD_VERSION)] + /// ^ This expected error may change depending on the migration. In most + /// cases, this will abort with `wormhole::package_utils::E_INCORRECT_OLD_VERSION`. + fun test_cannot_migrate_again() { + use wormhole::migrate::{migrate}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + // Initialize Wormhole. + let wormhole_message_fee = 350; + set_up_wormhole(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + // Upgrade (digest is just b"new build") for testing purposes. + upgrade_wormhole(scenario); + + // Ignore effects. + test_scenario::next_tx(scenario, user); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Set up migrate (which prepares this package to be the same state as + // a previous release). + wormhole::migrate::set_up_migrate(&mut worm_state); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + migrate(&mut worm_state, UPGRADE_VAA, &the_clock); + + // Make sure we emitted an event. + let effects = test_scenario::next_tx(scenario, user); + assert!(test_scenario::num_user_events(&effects) == 1, 0); + + // You shall not pass! + migrate(&mut worm_state, UPGRADE_VAA, &the_clock); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/publish_message.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/publish_message.move new file mode 100644 index 0000000000..3255fee5ba --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/publish_message.move @@ -0,0 +1,426 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements two methods: `prepare_message` and `publish_message`, +/// which are to be executed in a transaction block in this order. +/// +/// `prepare_message` allows a contract to pack Wormhole message info (payload +/// that has meaning to an integrator plus nonce) in preparation to publish a +/// `WormholeMessage` event via `publish_message`. Only the owner of an +/// `EmitterCap` has the capability of creating this `MessageTicket`. +/// +/// `publish_message` unpacks the `MessageTicket` and emits a +/// `WormholeMessage` with this message info and timestamp. This event is +/// observed by the Guardian network. +/// +/// The purpose of splitting this message publishing into two steps is in case +/// Wormhole needs to be upgraded and there is a breaking change for this +/// module, an integrator would not be left broken. It is discouraged to put +/// `publish_message` in an integrator's package logic. Otherwise, this +/// integrator needs to be prepared to upgrade his contract to handle the latest +/// version of `publish_message`. +/// +/// Instead, an integtrator is encouraged to execute a transaction block, which +/// executes `publish_message` using the latest Wormhole package ID and to +/// implement `prepare_message` in his contract to produce `MessageTicket`, +/// which `publish_message` consumes. +module wormhole::publish_message { + use sui::coin::{Self, Coin}; + use sui::clock::{Self, Clock}; + use sui::object::{Self, ID}; + use sui::sui::{SUI}; + + use wormhole::emitter::{Self, EmitterCap}; + use wormhole::state::{Self, State}; + + /// This type is emitted via `sui::event` module. Guardians pick up this + /// observation and attest to its existence. + struct WormholeMessage has drop, copy { + /// `EmitterCap` object ID. + sender: ID, + /// From `EmitterCap`. + sequence: u64, + /// A.K.A. Batch ID. + nonce: u32, + /// Arbitrary message data relevant to integrator. + payload: vector, + /// This will always be `0`. + consistency_level: u8, + /// `Clock` timestamp. + timestamp: u64 + } + + /// This type represents Wormhole message data. The sender is the object ID + /// of an `EmitterCap`, who acts as the capability of creating this type. + /// The only way to destroy this type is calling `publish_message` with + /// a fee to emit a `WormholeMessage` with the unpacked members of this + /// struct. + struct MessageTicket { + /// `EmitterCap` object ID. + sender: ID, + /// From `EmitterCap`. + sequence: u64, + /// A.K.A. Batch ID. + nonce: u32, + /// Arbitrary message data relevant to integrator. + payload: vector + } + + /// `prepare_message` constructs Wormhole message parameters. An + /// `EmitterCap` provides the capability to send an arbitrary payload. + /// + /// NOTE: Integrators of Wormhole should be calling only this method from + /// their contracts. This method is not guarded by version control (thus not + /// requiring a reference to the Wormhole `State` object), so it is intended + /// to work for any package version. + public fun prepare_message( + emitter_cap: &mut EmitterCap, + nonce: u32, + payload: vector + ): MessageTicket { + // Produce sequence number for this message. This will also be the + // return value for this method. + let sequence = emitter::use_sequence(emitter_cap); + + MessageTicket { + sender: object::id(emitter_cap), + sequence, + nonce, + payload + } + } + + /// `publish_message` emits a message as a Sui event. This method uses the + /// input `EmitterCap` as the registered sender of the + /// `WormholeMessage`. It also produces a new sequence for this emitter. + /// + /// NOTE: This method is guarded by a minimum build version check. This + /// method could break backward compatibility on an upgrade. + /// + /// It is important for integrators to refrain from calling this method + /// within their contracts. This method is meant to be called in a + /// transaction block after receiving a `MessageTicket` from calling + /// `prepare_message` within a contract. If in a circumstance where this + /// module has a breaking change in an upgrade, `prepare_message` will not + /// be affected by this change. + /// + /// See `prepare_message` for more details. + public fun publish_message( + wormhole_state: &mut State, + message_fee: Coin, + prepared_msg: MessageTicket, + the_clock: &Clock + ): u64 { + // This capability ensures that the current build version is used. + let latest_only = state::assert_latest_only(wormhole_state); + + // Deposit `message_fee`. This method interacts with the `FeeCollector`, + // which will abort if `message_fee` does not equal the collector's + // expected fee amount. + state::deposit_fee( + &latest_only, + wormhole_state, + coin::into_balance(message_fee) + ); + + let MessageTicket { + sender, + sequence, + nonce, + payload + } = prepared_msg; + + // Truncate to seconds. + let timestamp = clock::timestamp_ms(the_clock) / 1000; + + // Sui is an instant finality chain, so we don't need confirmations. + let consistency_level = 0; + + // Emit Sui event with `WormholeMessage`. + sui::event::emit( + WormholeMessage { + sender, + sequence, + nonce, + payload, + consistency_level, + timestamp + } + ); + + // Done. + sequence + } + + #[test_only] + public fun destroy(prepared_msg: MessageTicket) { + let MessageTicket { + sender: _, + sequence: _, + nonce: _, + payload: _ + } = prepared_msg; + } +} + +#[test_only] +module wormhole::publish_message_tests { + use sui::coin::{Self}; + use sui::test_scenario::{Self}; + + use wormhole::emitter::{Self, EmitterCap}; + use wormhole::fee_collector::{Self}; + use wormhole::state::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + person, + return_clock, + return_state, + set_up_wormhole, + take_clock, + take_state, + upgrade_wormhole + }; + + #[test] + /// This test verifies that `publish_message` is successfully called when + /// the specified message fee is used. + fun test_publish_message() { + use wormhole::publish_message::{prepare_message, publish_message}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + let wormhole_message_fee = 100000000; + + // Initialize Wormhole. + set_up_wormhole(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + { + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // User needs an `EmitterCap` so he can send a message. + let emitter_cap = + wormhole::emitter::new( + &worm_state, + test_scenario::ctx(scenario) + ); + + // Check for event corresponding to new emitter. + let effects = test_scenario::next_tx(scenario, user); + assert!(test_scenario::num_user_events(&effects) == 1, 0); + + // Prepare message. + let msg = + prepare_message( + &mut emitter_cap, + 0, // nonce + b"Hello World" + ); + + // Finally publish Wormhole message. + let sequence = + publish_message( + &mut worm_state, + coin::mint_for_testing( + wormhole_message_fee, + test_scenario::ctx(scenario) + ), + msg, + &the_clock + ); + assert!(sequence == 0, 0); + + // Prepare another message. + let msg = + prepare_message( + &mut emitter_cap, + 0, // nonce + b"Hello World... again" + ); + + // Publish again to check sequence uptick. + let another_sequence = + publish_message( + &mut worm_state, + coin::mint_for_testing( + wormhole_message_fee, + test_scenario::ctx(scenario) + ), + msg, + &the_clock + ); + assert!(another_sequence == 1, 0); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + sui::transfer::public_transfer(emitter_cap, user); + }; + + // Grab the `TransactionEffects` of the previous transaction. + let effects = test_scenario::next_tx(scenario, user); + + // We expect two events (the Wormhole messages). `test_scenario` does + // not give us an in-depth view of the event specifically. But we can + // check that there was an event associated with the previous + // transaction. + assert!(test_scenario::num_user_events(&effects) == 2, 0); + + // Simulate upgrade and confirm that publish message still works. + { + upgrade_wormhole(scenario); + + // Ignore effects from upgrade. + test_scenario::next_tx(scenario, user); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + let emitter_cap = + test_scenario::take_from_sender(scenario); + + let msg = + prepare_message( + &mut emitter_cap, + 0, // nonce + b"Hello?" + ); + + let sequence = + publish_message( + &mut worm_state, + coin::mint_for_testing( + wormhole_message_fee, + test_scenario::ctx(scenario) + ), + msg, + &the_clock + ); + assert!(sequence == 2, 0); + + // Clean up. + test_scenario::return_to_sender(scenario, emitter_cap); + return_state(worm_state); + return_clock(the_clock); + }; + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = fee_collector::E_INCORRECT_FEE)] + /// This test verifies that `publish_message` fails when the fee is not the + /// correct amount. `FeeCollector` will be the reason for this abort. + fun test_cannot_publish_message_with_incorrect_fee() { + use wormhole::publish_message::{prepare_message, publish_message}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + let wormhole_message_fee = 100000000; + let wrong_fee_amount = wormhole_message_fee - 1; + + // Initialize Wormhole. + set_up_wormhole(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // User needs an `EmitterCap` so he can send a message. + let emitter_cap = + emitter::new(&worm_state, test_scenario::ctx(scenario)); + + let msg = + prepare_message( + &mut emitter_cap, + 0, // nonce + b"Hello World" + ); + // You shall not pass! + publish_message( + &mut worm_state, + coin::mint_for_testing( + wrong_fee_amount, + test_scenario::ctx(scenario) + ), + msg, + &the_clock + ); + + // Clean up. + emitter::destroy_test_only(emitter_cap); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + /// This test verifies that `publish_message` will fail if the minimum + /// required version is greater than the current build's. + fun test_cannot_publish_message_outdated_version() { + use wormhole::publish_message::{prepare_message, publish_message}; + + let user = person(); + let my_scenario = test_scenario::begin(user); + let scenario = &mut my_scenario; + + let wormhole_message_fee = 100000000; + + // Initialize Wormhole. + set_up_wormhole(scenario, wormhole_message_fee); + + // Next transaction should be conducted as an ordinary user. + test_scenario::next_tx(scenario, user); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // User needs an `EmitterCap` so he can send a message. + let emitter_cap = + emitter::new(&worm_state, test_scenario::ctx(scenario)); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + let msg = + prepare_message( + &mut emitter_cap, + 0, // nonce + b"Hello World", + ); + + // You shall not pass! + publish_message( + &mut worm_state, + coin::mint_for_testing( + wormhole_message_fee, + test_scenario::ctx(scenario) + ), + msg, + &the_clock + ); + + // Clean up. + emitter::destroy_test_only(emitter_cap); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/consumed_vaas.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/consumed_vaas.move new file mode 100644 index 0000000000..a09327cf7e --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/consumed_vaas.move @@ -0,0 +1,29 @@ +module wormhole::consumed_vaas { + use sui::tx_context::{TxContext}; + + use wormhole::bytes32::{Bytes32}; + use wormhole::set::{Self, Set}; + + /// Container storing VAA hashes (digests). This will be checked against in + /// `parse_verify_and_consume` so a particular VAA cannot be replayed. It + /// is up to the integrator to have this container live in his contract + /// in order to take advantage of this no-replay protection. Or an + /// integrator can implement his own method to prevent replay. + struct ConsumedVAAs has store { + hashes: Set + } + + public fun new(ctx: &mut TxContext): ConsumedVAAs { + ConsumedVAAs { hashes: set::new(ctx) } + } + + public fun consume(self: &mut ConsumedVAAs, digest: Bytes32) { + set::add(&mut self.hashes, digest); + } + + #[test_only] + public fun destroy(consumed: ConsumedVAAs) { + let ConsumedVAAs { hashes } = consumed; + set::destroy(hashes); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/fee_collector.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/fee_collector.move new file mode 100644 index 0000000000..f75ab49719 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/fee_collector.move @@ -0,0 +1,170 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a container that collects fees in SUI denomination. +/// The `FeeCollector` requires that the fee deposited is exactly equal to the +/// `fee_amount` configured. +module wormhole::fee_collector { + use sui::balance::{Self, Balance}; + use sui::coin::{Self, Coin}; + use sui::sui::{SUI}; + use sui::tx_context::{TxContext}; + + /// Amount deposited is not exactly the amount configured. + const E_INCORRECT_FEE: u64 = 0; + + /// Container for configured `fee_amount` and `balance` of SUI collected. + struct FeeCollector has store { + fee_amount: u64, + balance: Balance + } + + /// Create new `FeeCollector` with specified amount to collect. + public fun new(fee_amount: u64): FeeCollector { + FeeCollector { fee_amount, balance: balance::zero() } + } + + /// Retrieve configured amount to collect. + public fun fee_amount(self: &FeeCollector): u64 { + self.fee_amount + } + + /// Retrieve current SUI balance. + public fun balance_value(self: &FeeCollector): u64 { + balance::value(&self.balance) + } + + /// Take `Balance` and add it to current collected balance. + public fun deposit_balance(self: &mut FeeCollector, fee: Balance) { + assert!(balance::value(&fee) == self.fee_amount, E_INCORRECT_FEE); + balance::join(&mut self.balance, fee); + } + + /// Take `Coin` and add it to current collected balance. + public fun deposit(self: &mut FeeCollector, fee: Coin) { + deposit_balance(self, coin::into_balance(fee)) + } + + /// Create `Balance` of some `amount` by taking from collected balance. + public fun withdraw_balance( + self: &mut FeeCollector, + amount: u64 + ): Balance { + // This will trigger `sui::balance::ENotEnough` if amount > balance. + balance::split(&mut self.balance, amount) + } + + /// Create `Coin` of some `amount` by taking from collected balance. + public fun withdraw( + self: &mut FeeCollector, + amount: u64, + ctx: &mut TxContext + ): Coin { + coin::from_balance(withdraw_balance(self, amount), ctx) + } + + /// Re-configure current `fee_amount`. + public fun change_fee(self: &mut FeeCollector, new_amount: u64) { + self.fee_amount = new_amount; + } + + #[test_only] + public fun destroy(collector: FeeCollector) { + let FeeCollector { fee_amount: _, balance: bal } = collector; + balance::destroy_for_testing(bal); + } +} + +#[test_only] +module wormhole::fee_collector_tests { + use sui::coin::{Self}; + use sui::tx_context::{Self}; + + use wormhole::fee_collector::{Self}; + + #[test] + public fun test_fee_collector() { + let ctx = &mut tx_context::dummy(); + + let fee_amount = 350; + let collector = fee_collector::new(fee_amount); + + // We expect the fee_amount to be the same as what we specified and + // no balance on `FeeCollector` yet. + assert!(fee_collector::fee_amount(&collector) == fee_amount, 0); + assert!(fee_collector::balance_value(&collector) == 0, 0); + + // Deposit fee once. + let fee = coin::mint_for_testing(fee_amount, ctx); + fee_collector::deposit(&mut collector, fee); + assert!(fee_collector::balance_value(&collector) == fee_amount, 0); + + // Now deposit nine more times and check the aggregate balance. + let i = 0; + while (i < 9) { + let fee = coin::mint_for_testing(fee_amount, ctx); + fee_collector::deposit(&mut collector, fee); + i = i + 1; + }; + let total = fee_collector::balance_value(&collector); + assert!(total == 10 * fee_amount, 0); + + // Withdraw a fifth. + let withdraw_amount = total / 5; + let withdrawn = + fee_collector::withdraw(&mut collector, withdraw_amount, ctx); + assert!(coin::value(&withdrawn) == withdraw_amount, 0); + coin::burn_for_testing(withdrawn); + + let remaining = fee_collector::balance_value(&collector); + assert!(remaining == total - withdraw_amount, 0); + + // Withdraw remaining. + let withdrawn = fee_collector::withdraw(&mut collector, remaining, ctx); + assert!(coin::value(&withdrawn) == remaining, 0); + coin::burn_for_testing(withdrawn); + + // There shouldn't be anything left in `FeeCollector`. + assert!(fee_collector::balance_value(&collector) == 0, 0); + + // Done. + fee_collector::destroy(collector); + } + + #[test] + #[expected_failure(abort_code = fee_collector::E_INCORRECT_FEE)] + public fun test_cannot_deposit_incorrect_fee() { + let ctx = &mut tx_context::dummy(); + + let fee_amount = 350; + let collector = fee_collector::new(fee_amount); + + // You shall not pass! + let fee = coin::mint_for_testing(fee_amount + 1, ctx); + fee_collector::deposit(&mut collector, fee); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = sui::balance::ENotEnough)] + public fun test_cannot_withdraw_more_than_balance() { + let ctx = &mut tx_context::dummy(); + + let fee_amount = 350; + let collector = fee_collector::new(fee_amount); + + // Deposit once. + let fee = coin::mint_for_testing(fee_amount, ctx); + fee_collector::deposit(&mut collector, fee); + + // Attempt to withdraw more than the balance. + let bal = fee_collector::balance_value(&collector); + let withdrawn = + fee_collector::withdraw(&mut collector, bal + 1, ctx); + + // Shouldn't get here. But we need to clean up anyway. + coin::burn_for_testing(withdrawn); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/guardian.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/guardian.move new file mode 100644 index 0000000000..84c6a48eb1 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/guardian.move @@ -0,0 +1,83 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a `Guardian` that warehouses a 20-byte public key. +module wormhole::guardian { + use std::vector::{Self}; + use sui::hash::{Self}; + use sui::ecdsa_k1::{Self}; + + use wormhole::bytes20::{Self, Bytes20}; + use wormhole::guardian_signature::{Self, GuardianSignature}; + + /// Guardian public key is all zeros. + const E_ZERO_ADDRESS: u64 = 1; + + /// Container for 20-byte Guardian public key. + struct Guardian has store { + pubkey: Bytes20 + } + + /// Create new `Guardian` ensuring that the input is not all zeros. + public fun new(pubkey: vector): Guardian { + let data = bytes20::new(pubkey); + assert!(bytes20::is_nonzero(&data), E_ZERO_ADDRESS); + Guardian { pubkey: data } + } + + /// Retrieve underlying 20-byte public key. + public fun pubkey(self: &Guardian): Bytes20 { + self.pubkey + } + + /// Retrieve underlying 20-byte public key as `vector`. + public fun as_bytes(self: &Guardian): vector { + bytes20::data(&self.pubkey) + } + + /// Verify that the recovered public key (using `ecrecover`) equals the one + /// that exists for this Guardian with an elliptic curve signature and raw + /// message that was signed. + public fun verify( + self: &Guardian, + signature: GuardianSignature, + message_hash: vector + ): bool { + let sig = guardian_signature::to_rsv(signature); + as_bytes(self) == ecrecover(message_hash, sig) + } + + /// Same as 'ecrecover' in EVM. + fun ecrecover(message: vector, sig: vector): vector { + let pubkey = + ecdsa_k1::decompress_pubkey(&ecdsa_k1::secp256k1_ecrecover(&sig, &message, 0)); + + // `decompress_pubkey` returns 65 bytes. The last 64 bytes are what we + // need to compute the Guardian's public key. + vector::remove(&mut pubkey, 0); + + let hash = hash::keccak256(&pubkey); + let guardian_pubkey = vector::empty(); + let (i, n) = (0, bytes20::length()); + while (i < n) { + vector::push_back( + &mut guardian_pubkey, + vector::pop_back(&mut hash) + ); + i = i + 1; + }; + vector::reverse(&mut guardian_pubkey); + + guardian_pubkey + } + + #[test_only] + public fun destroy(g: Guardian) { + let Guardian { pubkey: _ } = g; + } + + #[test_only] + public fun to_bytes(value: Guardian): vector { + let Guardian { pubkey } = value; + bytes20::to_bytes(pubkey) + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/guardian_set.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/guardian_set.move new file mode 100644 index 0000000000..e55ccd3758 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/guardian_set.move @@ -0,0 +1,193 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a container that keeps track of a list of Guardian +/// public keys and which Guardian set index this list of Guardians represents. +/// Each guardian set is unique and there should be no two sets that have the +/// same Guardian set index (which requirement is handled in `wormhole::state`). +/// +/// If the current Guardian set is not the latest one, its `expiration_time` is +/// configured, which defines how long the past Guardian set can be active. +module wormhole::guardian_set { + use std::vector::{Self}; + use sui::clock::{Self, Clock}; + + use wormhole::guardian::{Self, Guardian}; + + // Needs `set_expiration`. + friend wormhole::state; + + /// Found duplicate public key. + const E_DUPLICATE_GUARDIAN: u64 = 0; + + /// Container for the list of Guardian public keys, its index value and at + /// what point in time the Guardian set is configured to expire. + struct GuardianSet has store { + /// A.K.A. Guardian set index. + index: u32, + + /// List of Guardians. This order should not change. + guardians: vector, + + /// At what point in time the Guardian set is no longer active (in ms). + expiration_timestamp_ms: u64, + } + + /// Create new `GuardianSet`. + public fun new(index: u32, guardians: vector): GuardianSet { + // Ensure that there are no duplicate guardians. + let (i, n) = (0, vector::length(&guardians)); + while (i < n - 1) { + let left = guardian::pubkey(vector::borrow(&guardians, i)); + let j = i + 1; + while (j < n) { + let right = guardian::pubkey(vector::borrow(&guardians, j)); + assert!(left != right, E_DUPLICATE_GUARDIAN); + j = j + 1; + }; + i = i + 1; + }; + + GuardianSet { index, guardians, expiration_timestamp_ms: 0 } + } + + /// Retrieve the Guardian set index. + public fun index(self: &GuardianSet): u32 { + self.index + } + + /// Retrieve the Guardian set index as `u64` (for convenience when used to + /// compare to indices for iterations, which are natively `u64`). + public fun index_as_u64(self: &GuardianSet): u64 { + (self.index as u64) + } + + /// Retrieve list of Guardians. + public fun guardians(self: &GuardianSet): &vector { + &self.guardians + } + + /// Retrieve specific Guardian by index (in the array representing the set). + public fun guardian_at(self: &GuardianSet, index: u64): &Guardian { + vector::borrow(&self.guardians, index) + } + + /// Retrieve when the Guardian set is no longer active. + public fun expiration_timestamp_ms(self: &GuardianSet): u64 { + self.expiration_timestamp_ms + } + + /// Retrieve whether this Guardian set is still active by checking the + /// current time. + public fun is_active(self: &GuardianSet, clock: &Clock): bool { + ( + self.expiration_timestamp_ms == 0 || + self.expiration_timestamp_ms > clock::timestamp_ms(clock) + ) + } + + /// Retrieve how many guardians exist in the Guardian set. + public fun num_guardians(self: &GuardianSet): u64 { + vector::length(&self.guardians) + } + + /// Returns the minimum number of signatures required for a VAA to be valid. + public fun quorum(self: &GuardianSet): u64 { + (num_guardians(self) * 2) / 3 + 1 + } + + /// Configure this Guardian set to expire from some amount of time based on + /// what time it is right now. + /// + /// NOTE: `time_to_live` is in units of seconds while `Clock` uses + /// milliseconds. + public(friend) fun set_expiration( + self: &mut GuardianSet, + seconds_to_live: u32, + the_clock: &Clock + ) { + let ttl_ms = (seconds_to_live as u64) * 1000; + self.expiration_timestamp_ms = clock::timestamp_ms(the_clock) + ttl_ms; + } + + #[test_only] + public fun destroy(set: GuardianSet) { + use wormhole::guardian::{Self}; + + let GuardianSet { + index: _, + guardians, + expiration_timestamp_ms: _ + } = set; + while (!vector::is_empty(&guardians)) { + guardian::destroy(vector::pop_back(&mut guardians)); + }; + + vector::destroy_empty(guardians); + } +} + +#[test_only] +module wormhole::guardian_set_tests { + use std::vector::{Self}; + + use wormhole::guardian::{Self}; + use wormhole::guardian_set::{Self}; + + #[test] + fun test_new() { + let guardians = vector::empty(); + + let pubkeys = vector[ + x"8888888888888888888888888888888888888888", + x"9999999999999999999999999999999999999999", + x"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + x"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + x"cccccccccccccccccccccccccccccccccccccccc", + x"dddddddddddddddddddddddddddddddddddddddd", + x"eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", + x"ffffffffffffffffffffffffffffffffffffffff" + ]; + while (!vector::is_empty(&pubkeys)) { + vector::push_back( + &mut guardians, + guardian::new(vector::pop_back(&mut pubkeys)) + ); + }; + + let set = guardian_set::new(69, guardians); + + // Clean up. + guardian_set::destroy(set); + } + + #[test] + #[expected_failure(abort_code = guardian_set::E_DUPLICATE_GUARDIAN)] + fun test_cannot_new_duplicate_guardian() { + let guardians = vector::empty(); + + let pubkeys = vector[ + x"8888888888888888888888888888888888888888", + x"9999999999999999999999999999999999999999", + x"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + x"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + x"cccccccccccccccccccccccccccccccccccccccc", + x"dddddddddddddddddddddddddddddddddddddddd", + x"eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", + x"ffffffffffffffffffffffffffffffffffffffff", + x"cccccccccccccccccccccccccccccccccccccccc", + ]; + while (!vector::is_empty(&pubkeys)) { + vector::push_back( + &mut guardians, + guardian::new(vector::pop_back(&mut pubkeys)) + ); + }; + + let set = guardian_set::new(69, guardians); + + // Clean up. + guardian_set::destroy(set); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/set.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/set.move new file mode 100644 index 0000000000..bb52326489 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/resources/set.move @@ -0,0 +1,88 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type that resembles the set data structure. +/// `Set` leverages `sui::table` to store unique keys of the same type. +/// +/// NOTE: Items added to this data structure cannot be removed. +module wormhole::set { + use sui::table::{Self, Table}; + use sui::tx_context::{TxContext}; + + /// Explicit error if key already exists in `Set`. + const E_KEY_ALREADY_EXISTS: u64 = 0; + /// Explicit error if key does not exist in `Set`. + const E_KEY_NONEXISTENT: u64 = 1; + + /// Empty struct. Used as the value type in mappings to encode a set + struct Empty has store, drop {} + + /// A set containing elements of type `T` with support for membership + /// checking. + struct Set has store { + items: Table + } + + /// Create a new Set. + public fun new(ctx: &mut TxContext): Set { + Set { items: table::new(ctx) } + } + + /// Add a new element to the set. + /// Aborts if the element already exists + public fun add(self: &mut Set, key: T) { + assert!(!contains(self, key), E_KEY_ALREADY_EXISTS); + table::add(&mut self.items, key, Empty {}) + } + + /// Returns true iff `set` contains an entry for `key`. + public fun contains(self: &Set, key: T): bool { + table::contains(&self.items, key) + } + + public fun remove(self: &mut Set, key: T) { + assert!(contains(self, key), E_KEY_NONEXISTENT); + table::remove(&mut self.items, key); + } + + #[test_only] + public fun destroy(set: Set) { + let Set { items } = set; + table::drop(items); + } + +} + +#[test_only] +module wormhole::set_tests { + use sui::tx_context::{Self}; + + use wormhole::set::{Self}; + + #[test] + public fun test_add_and_contains() { + let ctx = &mut tx_context::dummy(); + + let my_set = set::new(ctx); + + let (i, n) = (0, 256); + while (i < n) { + set::add(&mut my_set, i); + i = i + 1; + }; + + // Check that the set has the values just added. + let i = 0; + while (i < n) { + assert!(set::contains(&my_set, i), 0); + i = i + 1; + }; + + // Check that these values that were not added are not in the set. + while (i < 2 * n) { + assert!(!set::contains(&my_set, i), 0); + i = i + 1; + }; + + set::destroy(my_set); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/setup.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/setup.move new file mode 100644 index 0000000000..c7f233e102 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/setup.move @@ -0,0 +1,327 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements the mechanism to publish the Wormhole contract and +/// initialize `State` as a shared object. +module wormhole::setup { + use std::vector::{Self}; + use sui::object::{Self, UID}; + use sui::package::{Self, UpgradeCap}; + use sui::transfer::{Self}; + use sui::tx_context::{Self, TxContext}; + + use wormhole::cursor::{Self}; + use wormhole::state::{Self}; + + /// Capability created at `init`, which will be destroyed once + /// `init_and_share_state` is called. This ensures only the deployer can + /// create the shared `State`. + struct DeployerCap has key, store { + id: UID + } + + /// Called automatically when module is first published. Transfers + /// `DeployerCap` to sender. + /// + /// Only `setup::init_and_share_state` requires `DeployerCap`. + fun init(ctx: &mut TxContext) { + let deployer = DeployerCap { id: object::new(ctx) }; + transfer::transfer(deployer, tx_context::sender(ctx)); + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(ctx); + + // This will be created and sent to the transaction sender + // automatically when the contract is published. + transfer::public_transfer( + sui::package::test_publish(object::id_from_address(@wormhole), ctx), + tx_context::sender(ctx) + ); + } + + #[allow(lint(share_owned))] + /// Only the owner of the `DeployerCap` can call this method. This + /// method destroys the capability and shares the `State` object. + public fun complete( + deployer: DeployerCap, + upgrade_cap: UpgradeCap, + governance_chain: u16, + governance_contract: vector, + guardian_set_index: u32, + initial_guardians: vector>, + guardian_set_seconds_to_live: u32, + message_fee: u64, + ctx: &mut TxContext + ) { + wormhole::package_utils::assert_package_upgrade_cap( + &upgrade_cap, + package::compatible_policy(), + 1 + ); + + // Destroy deployer cap. + let DeployerCap { id } = deployer; + object::delete(id); + + let guardians = { + let out = vector::empty(); + let cur = cursor::new(initial_guardians); + while (!cursor::is_empty(&cur)) { + vector::push_back( + &mut out, + wormhole::guardian::new(cursor::poke(&mut cur)) + ); + }; + cursor::destroy_empty(cur); + out + }; + + // Share new state. + transfer::public_share_object( + state::new( + upgrade_cap, + governance_chain, + wormhole::external_address::new_nonzero( + wormhole::bytes32::from_bytes(governance_contract) + ), + guardian_set_index, + guardians, + guardian_set_seconds_to_live, + message_fee, + ctx + ) + ); + } +} + +#[test_only] +module wormhole::setup_tests { + use std::option::{Self}; + use std::vector::{Self}; + use sui::package::{Self}; + use sui::object::{Self}; + use sui::test_scenario::{Self}; + + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self}; + use wormhole::guardian::{Self}; + use wormhole::guardian_set::{Self}; + use wormhole::setup::{Self, DeployerCap}; + use wormhole::state::{Self, State}; + use wormhole::wormhole_scenario::{person}; + + #[test] + fun test_init() { + let deployer = person(); + let my_scenario = test_scenario::begin(deployer); + let scenario = &mut my_scenario; + + // Initialize Wormhole smart contract. + setup::init_test_only(test_scenario::ctx(scenario)); + + // Process effects of `init`. + let effects = test_scenario::next_tx(scenario, deployer); + + // We expect two objects to be created: `DeployerCap` and `UpgradeCap`. + assert!(vector::length(&test_scenario::created(&effects)) == 2, 0); + + // We should be able to take the `DeployerCap` from the sender + // of the transaction. + let cap = + test_scenario::take_from_address( + scenario, + deployer + ); + + // The above should succeed, so we will return to `deployer`. + test_scenario::return_to_address(deployer, cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + fun test_complete() { + let deployer = person(); + let my_scenario = test_scenario::begin(deployer); + let scenario = &mut my_scenario; + + // Initialize Wormhole smart contract. + setup::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, deployer); + + let governance_chain = 1234; + let governance_contract = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + let guardian_set_index = 0; + let initial_guardians = + vector[ + x"1337133713371337133713371337133713371337", + x"c0dec0dec0dec0dec0dec0dec0dec0dec0dec0de", + x"ba5edba5edba5edba5edba5edba5edba5edba5ed" + ]; + let guardian_set_seconds_to_live = 5678; + let message_fee = 350; + + // Take the `DeployerCap` and move it to `init_and_share_state`. + let deployer_cap = + test_scenario::take_from_address( + scenario, + deployer + ); + let deployer_cap_id = object::id(&deployer_cap); + + // This will be created and sent to the transaction sender automatically + // when the contract is published. This exists in place of grabbing + // it from the sender. + let upgrade_cap = + package::test_publish( + object::id_from_address(@wormhole), + test_scenario::ctx(scenario) + ); + + setup::complete( + deployer_cap, + upgrade_cap, + governance_chain, + governance_contract, + guardian_set_index, + initial_guardians, + guardian_set_seconds_to_live, + message_fee, + test_scenario::ctx(scenario) + ); + + // Process effects. + let effects = test_scenario::next_tx(scenario, deployer); + + // We expect one object to be created: `State`. And it is shared. + let created = test_scenario::created(&effects); + let shared = test_scenario::shared(&effects); + assert!(vector::length(&created) == 1, 0); + assert!(vector::length(&shared) == 1, 0); + assert!( + vector::borrow(&created, 0) == vector::borrow(&shared, 0), + 0 + ); + + // Verify `State`. Ideally we compare structs, but we will check each + // element. + let worm_state = test_scenario::take_shared(scenario); + + assert!(state::governance_chain(&worm_state) == governance_chain, 0); + + let expected_governance_contract = + external_address::new_nonzero( + bytes32::from_bytes(governance_contract) + ); + assert!( + state::governance_contract(&worm_state) == expected_governance_contract, + 0 + ); + + assert!(state::guardian_set_index(&worm_state) == 0, 0); + assert!( + state::guardian_set_seconds_to_live(&worm_state) == guardian_set_seconds_to_live, + 0 + ); + + let guardians = + guardian_set::guardians( + state::guardian_set_at(&worm_state, 0) + ); + let num_guardians = vector::length(guardians); + assert!(num_guardians == vector::length(&initial_guardians), 0); + + let i = 0; + while (i < num_guardians) { + let left = guardian::as_bytes(vector::borrow(guardians, i)); + let right = *vector::borrow(&initial_guardians, i); + assert!(left == right, 0); + i = i + 1; + }; + + assert!(state::message_fee(&worm_state) == message_fee, 0); + + // Clean up. + test_scenario::return_shared(worm_state); + + // We expect `DeployerCap` to be destroyed. There are other + // objects deleted, but we only care about the deployer cap for this + // test. + let deleted = cursor::new(test_scenario::deleted(&effects)); + let found = option::none(); + while (!cursor::is_empty(&deleted)) { + let id = cursor::poke(&mut deleted); + if (id == deployer_cap_id) { + found = option::some(id); + } + }; + cursor::destroy_empty(deleted); + + // If we found the deployer cap, `found` will have the ID. + assert!(!option::is_none(&found), 0); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure( + abort_code = wormhole::package_utils::E_INVALID_UPGRADE_CAP + )] + fun test_cannot_complete_invalid_upgrade_cap() { + let deployer = person(); + let my_scenario = test_scenario::begin(deployer); + let scenario = &mut my_scenario; + + // Initialize Wormhole smart contract. + setup::init_test_only(test_scenario::ctx(scenario)); + + // Ignore effects. + test_scenario::next_tx(scenario, deployer); + + let governance_chain = 1234; + let governance_contract = + x"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + let guardian_set_index = 0; + let initial_guardians = + vector[x"1337133713371337133713371337133713371337"]; + let guardian_set_seconds_to_live = 5678; + let message_fee = 350; + + // Take the `DeployerCap` and move it to `init_and_share_state`. + let deployer_cap = + test_scenario::take_from_address( + scenario, + deployer + ); + + // This will be created and sent to the transaction sender automatically + // when the contract is published. This exists in place of grabbing + // it from the sender. + let upgrade_cap = + package::test_publish( + object::id_from_address(@0xbadc0de), + test_scenario::ctx(scenario) + ); + + setup::complete( + deployer_cap, + upgrade_cap, + governance_chain, + governance_contract, + guardian_set_index, + initial_guardians, + guardian_set_seconds_to_live, + message_fee, + test_scenario::ctx(scenario) + ); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/state.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/state.move new file mode 100644 index 0000000000..d3b1f0c94b --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/state.move @@ -0,0 +1,468 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements the global state variables for Wormhole as a shared +/// object. The `State` object is used to perform anything that requires access +/// to data that defines the Wormhole contract. Examples of which are publishing +/// Wormhole messages (requires depositing a message fee), verifying `VAA` by +/// checking signatures versus an existing Guardian set, and generating new +/// emitters for Wormhole integrators. +module wormhole::state { + use std::vector::{Self}; + use sui::balance::{Balance}; + use sui::clock::{Clock}; + use sui::object::{Self, ID, UID}; + use sui::package::{UpgradeCap, UpgradeReceipt, UpgradeTicket}; + use sui::sui::{SUI}; + use sui::table::{Self, Table}; + use sui::tx_context::{TxContext}; + + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::consumed_vaas::{Self, ConsumedVAAs}; + use wormhole::external_address::{ExternalAddress}; + use wormhole::fee_collector::{Self, FeeCollector}; + use wormhole::guardian::{Guardian}; + use wormhole::guardian_set::{Self, GuardianSet}; + use wormhole::package_utils::{Self}; + use wormhole::version_control::{Self}; + + friend wormhole::emitter; + friend wormhole::governance_message; + friend wormhole::migrate; + friend wormhole::publish_message; + friend wormhole::set_fee; + friend wormhole::setup; + friend wormhole::transfer_fee; + friend wormhole::update_guardian_set; + friend wormhole::upgrade_contract; + friend wormhole::vaa; + + /// Cannot initialize state with zero guardians. + const E_ZERO_GUARDIANS: u64 = 0; + /// Build digest does not agree with current implementation. + const E_INVALID_BUILD_DIGEST: u64 = 1; + + /// Sui's chain ID is hard-coded to one value. + const CHAIN_ID: u16 = 50076; + + /// Capability reflecting that the current build version is used to invoke + /// state methods. + struct LatestOnly has drop {} + + /// Container for all state variables for Wormhole. + struct State has key, store { + id: UID, + + /// Governance chain ID. + governance_chain: u16, + + /// Governance contract address. + governance_contract: ExternalAddress, + + /// Current active guardian set index. + guardian_set_index: u32, + + /// All guardian sets (including expired ones). + guardian_sets: Table, + + /// Period for which a guardian set stays active after it has been + /// replaced. + /// + /// NOTE: `Clock` timestamp is in units of ms while this value is in + /// terms of seconds. See `guardian_set` module for more info. + guardian_set_seconds_to_live: u32, + + /// Consumed VAA hashes to protect against replay. VAAs relevant to + /// Wormhole are just governance VAAs. + consumed_vaas: ConsumedVAAs, + + /// Wormhole fee collector. + fee_collector: FeeCollector, + + /// Upgrade capability. + upgrade_cap: UpgradeCap + } + + /// Create new `State`. This is only executed using the `setup` module. + public(friend) fun new( + upgrade_cap: UpgradeCap, + governance_chain: u16, + governance_contract: ExternalAddress, + guardian_set_index: u32, + initial_guardians: vector, + guardian_set_seconds_to_live: u32, + message_fee: u64, + ctx: &mut TxContext + ): State { + // We need at least one guardian. + assert!(vector::length(&initial_guardians) > 0, E_ZERO_GUARDIANS); + + let state = State { + id: object::new(ctx), + governance_chain, + governance_contract, + guardian_set_index, + guardian_sets: table::new(ctx), + guardian_set_seconds_to_live, + consumed_vaas: consumed_vaas::new(ctx), + fee_collector: fee_collector::new(message_fee), + upgrade_cap + }; + + // Set first version and initialize package info. This will be used for + // emitting information of successful migrations. + let upgrade_cap = &state.upgrade_cap; + package_utils::init_package_info( + &mut state.id, + version_control::current_version(), + upgrade_cap + ); + + // Store the initial guardian set. + add_new_guardian_set( + &assert_latest_only(&state), + &mut state, + guardian_set::new(guardian_set_index, initial_guardians) + ); + + state + } + + //////////////////////////////////////////////////////////////////////////// + // + // Simple Getters + // + // These methods do not require `LatestOnly` for access. Anyone is free to + // access these values. + // + //////////////////////////////////////////////////////////////////////////// + + /// Convenience method to get hard-coded Wormhole chain ID (recognized by + /// the Wormhole network). + public fun chain_id(): u16 { + CHAIN_ID + } + + /// Retrieve governance module name. + public fun governance_module(): Bytes32 { + // A.K.A. "Core". + bytes32::new( + x"00000000000000000000000000000000000000000000000000000000436f7265" + ) + } + + /// Retrieve governance chain ID, which is governance's emitter chain ID. + public fun governance_chain(self: &State): u16 { + self.governance_chain + } + + /// Retrieve governance emitter address. + public fun governance_contract(self: &State): ExternalAddress { + self.governance_contract + } + + /// Retrieve current Guardian set index. This value is important for + /// verifying VAA signatures and especially important for governance VAAs. + public fun guardian_set_index(self: &State): u32 { + self.guardian_set_index + } + + /// Retrieve how long after a Guardian set can live for in terms of Sui + /// timestamp (in seconds). + public fun guardian_set_seconds_to_live(self: &State): u32 { + self.guardian_set_seconds_to_live + } + + /// Retrieve a particular Guardian set by its Guardian set index. This + /// method is used when verifying a VAA. + /// + /// See `wormhole::vaa` for more info. + public fun guardian_set_at( + self: &State, + index: u32 + ): &GuardianSet { + table::borrow(&self.guardian_sets, index) + } + + /// Retrieve current fee to send Wormhole message. + public fun message_fee(self: &State): u64 { + fee_collector::fee_amount(&self.fee_collector) + } + + #[test_only] + public fun fees_collected(self: &State): u64 { + fee_collector::balance_value(&self.fee_collector) + } + + #[test_only] + public fun cache_latest_only_test_only(self: &State): LatestOnly { + assert_latest_only(self) + } + + #[test_only] + public fun deposit_fee_test_only(self: &mut State, fee: Balance) { + deposit_fee(&assert_latest_only(self), self, fee) + } + + #[test_only] + public fun migrate_version_test_only( + self: &mut State, + old_version: Old, + new_version: New + ) { + package_utils::update_version_type_test_only( + &mut self.id, + old_version, + new_version + ); + } + + #[test_only] + public fun test_upgrade(self: &mut State) { + let test_digest = bytes32::from_bytes(b"new build"); + let ticket = authorize_upgrade(self, test_digest); + let receipt = sui::package::test_upgrade(ticket); + commit_upgrade(self, receipt); + } + + #[test_only] + public fun reverse_migrate_version(self: &mut State) { + package_utils::update_version_type_test_only( + &mut self.id, + version_control::current_version(), + version_control::previous_version() + ); + } + + //////////////////////////////////////////////////////////////////////////// + // + // Privileged `State` Access + // + // This section of methods require a `LatestOnly`, which can only be created + // within the Wormhole package. This capability allows special access to + // the `State` object. + // + // NOTE: A lot of these methods are still marked as `(friend)` as a safety + // precaution. When a package is upgraded, friend modifiers can be + // removed. + // + //////////////////////////////////////////////////////////////////////////// + + /// Obtain a capability to interact with `State` methods. This method checks + /// that we are running the current build. + /// + /// NOTE: This method allows caching the current version check so we avoid + /// multiple checks to dynamic fields. + public(friend) fun assert_latest_only(self: &State): LatestOnly { + package_utils::assert_version( + &self.id, + version_control::current_version() + ); + + LatestOnly {} + } + + /// Deposit fee when sending Wormhole message. This method does not + /// necessarily have to be a `friend` to `wormhole::publish_message`. But + /// we also do not want an integrator to mistakenly deposit fees outside + /// of calling `publish_message`. + /// + /// See `wormhole::publish_message` for more info. + public(friend) fun deposit_fee( + _: &LatestOnly, + self: &mut State, + fee: Balance + ) { + fee_collector::deposit_balance(&mut self.fee_collector, fee); + } + + /// Withdraw collected fees when governance action to transfer fees to a + /// particular recipient. + /// + /// See `wormhole::transfer_fee` for more info. + public(friend) fun withdraw_fee( + _: &LatestOnly, + self: &mut State, + amount: u64 + ): Balance { + fee_collector::withdraw_balance(&mut self.fee_collector, amount) + } + + /// Store `VAA` hash as a way to claim a VAA. This method prevents a VAA + /// from being replayed. For Wormhole, the only VAAs that it cares about + /// being replayed are its governance actions. + public(friend) fun borrow_mut_consumed_vaas( + _: &LatestOnly, + self: &mut State + ): &mut ConsumedVAAs { + borrow_mut_consumed_vaas_unchecked(self) + } + + /// Store `VAA` hash as a way to claim a VAA. This method prevents a VAA + /// from being replayed. For Wormhole, the only VAAs that it cares about + /// being replayed are its governance actions. + /// + /// NOTE: This method does not require `LatestOnly`. Only methods in the + /// `upgrade_contract` module requires this to be unprotected to prevent + /// a corrupted upgraded contract from bricking upgradability. + public(friend) fun borrow_mut_consumed_vaas_unchecked( + self: &mut State + ): &mut ConsumedVAAs { + &mut self.consumed_vaas + } + + /// When a new guardian set is added to `State`, part of the process + /// involves setting the last known Guardian set's expiration time based + /// on how long a Guardian set can live for. + /// + /// See `guardian_set_epochs_to_live` for the parameter that determines how + /// long a Guardian set can live for. + /// + /// See `wormhole::update_guardian_set` for more info. + public(friend) fun expire_guardian_set( + _: &LatestOnly, + self: &mut State, + the_clock: &Clock + ) { + guardian_set::set_expiration( + table::borrow_mut(&mut self.guardian_sets, self.guardian_set_index), + self.guardian_set_seconds_to_live, + the_clock + ); + } + + /// Add the latest Guardian set from the governance action to update the + /// current guardian set. + /// + /// See `wormhole::update_guardian_set` for more info. + public(friend) fun add_new_guardian_set( + _: &LatestOnly, + self: &mut State, + new_guardian_set: GuardianSet + ) { + self.guardian_set_index = guardian_set::index(&new_guardian_set); + table::add( + &mut self.guardian_sets, + self.guardian_set_index, + new_guardian_set + ); + } + + /// Modify the cost to send a Wormhole message via governance. + /// + /// See `wormhole::set_fee` for more info. + public(friend) fun set_message_fee( + _: &LatestOnly, + self: &mut State, + amount: u64 + ) { + fee_collector::change_fee(&mut self.fee_collector, amount); + } + + public(friend) fun current_package(_: &LatestOnly, self: &State): ID { + package_utils::current_package(&self.id) + } + + //////////////////////////////////////////////////////////////////////////// + // + // Upgradability + // + // A special space that controls upgrade logic. These methods are invoked + // via the `upgrade_contract` module. + // + // Also in this section is managing contract migrations, which uses the + // `migrate` module to officially roll state access to the latest build. + // Only those methods that require `LatestOnly` will be affected by an + // upgrade. + // + //////////////////////////////////////////////////////////////////////////// + + /// Issue an `UpgradeTicket` for the upgrade. + /// + /// NOTE: The Sui VM performs a check that this method is executed from the + /// latest published package. If someone were to try to execute this using + /// a stale build, the transaction will revert with `PackageUpgradeError`, + /// specifically `PackageIDDoesNotMatch`. + public(friend) fun authorize_upgrade( + self: &mut State, + package_digest: Bytes32 + ): UpgradeTicket { + let cap = &mut self.upgrade_cap; + package_utils::authorize_upgrade(&mut self.id, cap, package_digest) + } + + /// Finalize the upgrade that ran to produce the given `receipt`. + /// + /// NOTE: The Sui VM performs a check that this method is executed from the + /// latest published package. If someone were to try to execute this using + /// a stale build, the transaction will revert with `PackageUpgradeError`, + /// specifically `PackageIDDoesNotMatch`. + public(friend) fun commit_upgrade( + self: &mut State, + receipt: UpgradeReceipt + ): (ID, ID) { + let cap = &mut self.upgrade_cap; + package_utils::commit_upgrade(&mut self.id, cap, receipt) + } + + /// Method executed by the `migrate` module to roll access from one package + /// to another. This method will be called from the upgraded package. + public(friend) fun migrate_version(self: &mut State) { + package_utils::migrate_version( + &mut self.id, + version_control::previous_version(), + version_control::current_version() + ); + } + + /// As a part of the migration, we verify that the upgrade contract VAA's + /// encoded package digest used in `migrate` equals the one used to conduct + /// the upgrade. + public(friend) fun assert_authorized_digest( + _: &LatestOnly, + self: &State, + digest: Bytes32 + ) { + let authorized = package_utils::authorized_digest(&self.id); + assert!(digest == authorized, E_INVALID_BUILD_DIGEST); + } + + //////////////////////////////////////////////////////////////////////////// + // + // Special State Interaction via Migrate + // + // A VERY special space that manipulates `State` via calling `migrate`. + // + // PLEASE KEEP ANY METHODS HERE AS FRIENDS. We want the ability to remove + // these for future builds. + // + //////////////////////////////////////////////////////////////////////////// + + /// This method is used to make modifications to `State` when `migrate` is + /// called. This method name should change reflecting which version this + /// contract is migrating to. + /// + /// NOTE: Please keep this method as public(friend) because we never want + /// to expose this method as a public method. + public(friend) fun migrate__v__0_2_0(_self: &mut State) { + // Intentionally do nothing. + } + + #[test_only] + /// Bloody hack. + /// + /// This method is used to set up tests where we migrate to a new version, + /// which is meant to test that modules protected by version control will + /// break. + public fun reverse_migrate__v__dummy(_self: &mut State) { + // Intentionally do nothing. + } + + //////////////////////////////////////////////////////////////////////////// + // + // Deprecated + // + // Dumping grounds for old structs and methods. These things should not + // be used in future builds. + // + //////////////////////////////////////////////////////////////////////////// +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/test/wormhole_scenario.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/test/wormhole_scenario.move new file mode 100644 index 0000000000..f587778e4c --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/test/wormhole_scenario.move @@ -0,0 +1,224 @@ +// SPDX-License-Identifier: Apache 2 + +#[test_only] +/// This module implements ways to initialize Wormhole in a test scenario. This +/// module includes a default method (`set_up_wormhole`) with only one of the +/// devnet (Tilt) Guardians. The private key for this Guardian is known (see the +/// main Wormhole repository at https://github.com/wormhole-foundation/wormhole +/// for the key), which allows an integrator to generate his own VAAs and +/// validate them with this test-only Wormhole instance. +module wormhole::wormhole_scenario { + use std::vector::{Self}; + use sui::clock::{Self, Clock}; + use sui::package::{UpgradeCap}; + use sui::test_scenario::{Self, Scenario}; + + use wormhole::emitter::{EmitterCap}; + use wormhole::governance_message::{Self, DecreeTicket, DecreeReceipt}; + use wormhole::setup::{Self, DeployerCap}; + use wormhole::state::{Self, State}; + use wormhole::vaa::{Self, VAA}; + + const DEPLOYER: address = @0xDEADBEEF; + const WALLET_1: address = @0xB0B1; + const WALLET_2: address = @0xB0B2; + const WALLET_3: address = @0xB0B3; + const VAA_VERIFIER: address = @0xD00D; + const EMITTER_MAKER: address = @0xFEED; + + /// Set up Wormhole with any guardian pubkeys. For most testing purposes, + /// please use `set_up_wormhole` which only uses one guardian. + /// + /// NOTE: This also creates `Clock` for testing. + public fun set_up_wormhole_with_guardians( + scenario: &mut Scenario, + message_fee: u64, + initial_guardians: vector>, + ) { + // Process effects prior. `init_test_only` will be executed as the + // Wormhole contract deployer. + test_scenario::next_tx(scenario, DEPLOYER); + + // `init` Wormhole contract as if it were published. + wormhole::setup::init_test_only(test_scenario::ctx(scenario)); + + // `init_and_share_state` will also be executed as the Wormhole deployer + // to destroy the `DeployerCap` to create a sharable `State`. + test_scenario::next_tx(scenario, DEPLOYER); + + // Parameters for Wormhole's `State` are common in the Wormhole testing + // environment aside from the `guardian_set_epochs_to_live`, which at + // the moment needs to be discussed on how to configure. As of now, + // there is no clock with unix timestamp to expire guardian sets in + // terms of human-interpretable time. + { + // This will be created and sent to the transaction sender + // automatically when the contract is published. This exists in + // place of grabbing it from the sender. + let upgrade_cap = + test_scenario::take_from_sender(scenario); + + let governance_chain = 1; + let governance_contract = + x"0000000000000000000000000000000000000000000000000000000000000004"; + let guardian_set_index = 0; + let guardian_set_seconds_to_live = 420; + + // Share `State`. + setup::complete( + test_scenario::take_from_address( + scenario, DEPLOYER + ), + upgrade_cap, + governance_chain, + governance_contract, + guardian_set_index, + initial_guardians, + guardian_set_seconds_to_live, + message_fee, + test_scenario::ctx(scenario) + ); + }; + + // Done. + } + + /// Set up Wormhole with only the first devnet guardian. + public fun set_up_wormhole(scenario: &mut Scenario, message_fee: u64) { + let initial_guardians = vector::empty(); + vector::push_back( + &mut initial_guardians, + *vector::borrow(&guardians(), 0) + ); + + set_up_wormhole_with_guardians(scenario, message_fee, initial_guardians) + } + + /// Perform an upgrade (which just upticks the current version of what the + /// `State` believes is true). + public fun upgrade_wormhole(scenario: &mut Scenario) { + // Clean up from activity prior. + test_scenario::next_tx(scenario, person()); + + let worm_state = take_state(scenario); + state::test_upgrade(&mut worm_state); + + // Clean up. + return_state(worm_state); + } + + /// Address of wallet that published Wormhole contract. + public fun deployer(): address { + DEPLOYER + } + + public fun person(): address { + WALLET_1 + } + + public fun two_people(): (address, address) { + (WALLET_1, WALLET_2) + } + + public fun three_people(): (address, address, address) { + (WALLET_1, WALLET_2, WALLET_3) + } + + /// All guardians that exist in devnet (Tilt) environment. + public fun guardians(): vector> { + vector[ + x"befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe", + x"88d7d8b32a9105d228100e72dffe2fae0705d31c", + x"58076f561cc62a47087b567c86f986426dfcd000", + x"bd6e9833490f8fa87c733a183cd076a6cbd29074", + x"b853fcf0a5c78c1b56d15fce7a154e6ebe9ed7a2", + x"af3503dbd2e37518ab04d7ce78b630f98b15b78a", + x"785632dea5609064803b1c8ea8bb2c77a6004bd1", + x"09a281a698c0f5ba31f158585b41f4f33659e54d", + x"3178443ab76a60e21690dbfb17f7f59f09ae3ea1", + x"647ec26ae49b14060660504f4da1c2059e1c5ab6", + x"810ac3d8e1258bd2f004a94ca0cd4c68fc1c0611", + x"80610e96d645b12f47ae5cf4546b18538739e90f", + x"2edb0d8530e31a218e72b9480202acbaeb06178d", + x"a78858e5e5c4705cdd4b668ffe3be5bae4867c9d", + x"5efe3a05efc62d60e1d19faeb56a80223cdd3472", + x"d791b7d32c05abb1cc00b6381fa0c4928f0c56fc", + x"14bc029b8809069093d712a3fd4dfab31963597e", + x"246ab29fc6ebedf2d392a51ab2dc5c59d0902a03", + x"132a84dfd920b35a3d0ba5f7a0635df298f9033e", + ] + } + + public fun take_state(scenario: &Scenario): State { + test_scenario::take_shared(scenario) + } + + public fun return_state(wormhole_state: State) { + test_scenario::return_shared(wormhole_state); + } + + public fun parse_and_verify_vaa( + scenario: &mut Scenario, + vaa_buf: vector + ): VAA { + test_scenario::next_tx(scenario, VAA_VERIFIER); + + let the_clock = take_clock(scenario); + let worm_state = take_state(scenario); + + let out = + vaa::parse_and_verify( + &worm_state, + vaa_buf, + &the_clock + ); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + out + } + + public fun verify_governance_vaa( + scenario: &mut Scenario, + verified_vaa: VAA, + ticket: DecreeTicket + ): DecreeReceipt { + test_scenario::next_tx(scenario, VAA_VERIFIER); + + let worm_state = take_state(scenario); + + let receipt = + governance_message::verify_vaa(&worm_state, verified_vaa, ticket); + + // Clean up. + return_state(worm_state); + + receipt + } + + public fun new_emitter( + scenario: &mut Scenario + ): EmitterCap { + test_scenario::next_tx(scenario, EMITTER_MAKER); + + let worm_state = take_state(scenario); + + let emitter = + wormhole::emitter::new(&worm_state, test_scenario::ctx(scenario)); + + // Clean up. + return_state(worm_state); + + emitter + } + + public fun take_clock(scenario: &mut Scenario): Clock { + clock::create_for_testing(test_scenario::ctx(scenario)) + } + + public fun return_clock(the_clock: Clock) { + clock::destroy_for_testing(the_clock) + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/utils/bytes.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/utils/bytes.move new file mode 100644 index 0000000000..0d181f6775 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/utils/bytes.move @@ -0,0 +1,232 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a library that serializes and deserializes specific +/// types into a buffer (i.e. `vector`). For serialization, the first +/// argument will be of `&mut vector`. For deserialization, the first +/// argument will be of `&mut Cursor` (see `wormhole::cursor` for more +/// details). +module wormhole::bytes { + use std::vector::{Self}; + use std::bcs::{Self}; + use wormhole::cursor::{Self, Cursor}; + + public fun push_u8(buf: &mut vector, v: u8) { + vector::push_back(buf, v); + } + + public fun push_u16_be(buf: &mut vector, value: u16) { + push_reverse(buf, value); + } + + public fun push_u32_be(buf: &mut vector, value: u32) { + push_reverse(buf, value); + } + + public fun push_u64_be(buf: &mut vector, value: u64) { + push_reverse(buf, value); + } + + public fun push_u128_be(buf: &mut vector, value: u128) { + push_reverse(buf, value); + } + + public fun push_u256_be(buf: &mut vector, value: u256) { + push_reverse(buf, value); + } + + public fun take_u8(cur: &mut Cursor): u8 { + cursor::poke(cur) + } + + public fun take_u16_be(cur: &mut Cursor): u16 { + let out = 0; + let i = 0; + while (i < 2) { + out = (out << 8) + (cursor::poke(cur) as u16); + i = i + 1; + }; + out + } + + public fun take_u32_be(cur: &mut Cursor): u32 { + let out = 0; + let i = 0; + while (i < 4) { + out = (out << 8) + (cursor::poke(cur) as u32); + i = i + 1; + }; + out + } + + public fun take_u64_be(cur: &mut Cursor): u64 { + let out = 0; + let i = 0; + while (i < 8) { + out = (out << 8) + (cursor::poke(cur) as u64); + i = i + 1; + }; + out + } + + public fun take_u128_be(cur: &mut Cursor): u128 { + let out = 0; + let i = 0; + while (i < 16) { + out = (out << 8) + (cursor::poke(cur) as u128); + i = i + 1; + }; + out + } + + public fun take_u256_be(cur: &mut Cursor): u256 { + let out = 0; + let i = 0; + while (i < 32) { + out = (out << 8) + (cursor::poke(cur) as u256); + i = i + 1; + }; + out + } + + public fun take_bytes(cur: &mut Cursor, num_bytes: u64): vector { + let out = vector::empty(); + let i = 0; + while (i < num_bytes) { + vector::push_back(&mut out, cursor::poke(cur)); + i = i + 1; + }; + out + } + + fun push_reverse(buf: &mut vector, v: T) { + let data = bcs::to_bytes(&v); + vector::reverse(&mut data); + vector::append(buf, data); + } +} + +#[test_only] +module wormhole::bytes_tests { + use std::vector::{Self}; + use wormhole::bytes::{Self}; + use wormhole::cursor::{Self}; + + #[test] + fun test_push_u8(){ + let u = 0x12; + let s = vector::empty(); + bytes::push_u8(&mut s, u); + let cur = cursor::new(s); + let p = bytes::take_u8(&mut cur); + cursor::destroy_empty(cur); + assert!(p==u, 0); + } + + #[test] + fun test_push_u16_be(){ + let u = 0x1234; + let s = vector::empty(); + bytes::push_u16_be(&mut s, u); + let cur = cursor::new(s); + let p = bytes::take_u16_be(&mut cur); + cursor::destroy_empty(cur); + assert!(p==u, 0); + } + + #[test] + fun test_push_u32_be(){ + let u = 0x12345678; + let s = vector::empty(); + bytes::push_u32_be(&mut s, u); + let cur = cursor::new(s); + let p = bytes::take_u32_be(&mut cur); + cursor::destroy_empty(cur); + assert!(p==u, 0); + } + + #[test] + fun test_push_u64_be(){ + let u = 0x1234567812345678; + let s = vector::empty(); + bytes::push_u64_be(&mut s, u); + let cur = cursor::new(s); + let p = bytes::take_u64_be(&mut cur); + cursor::destroy_empty(cur); + assert!(p==u, 0); + } + + #[test] + fun test_push_u128_be(){ + let u = 0x12345678123456781234567812345678; + let s = vector::empty(); + bytes::push_u128_be(&mut s, u); + let cur = cursor::new(s); + let p = bytes::take_u128_be(&mut cur); + cursor::destroy_empty(cur); + assert!(p==u, 0); + } + + #[test] + fun test_push_u256_be(){ + let u = + 0x4738691759099793746170047375612500000000000000000000000000009876; + let s = vector::empty(); + bytes::push_u256_be(&mut s, u); + assert!( + s == x"4738691759099793746170047375612500000000000000000000000000009876", + 0 + ); + } + + #[test] + fun test_take_u8() { + let cursor = cursor::new(x"99"); + let byte = bytes::take_u8(&mut cursor); + assert!(byte==0x99, 0); + cursor::destroy_empty(cursor); + } + + #[test] + fun test_take_u16_be() { + let cursor = cursor::new(x"9987"); + let u = bytes::take_u16_be(&mut cursor); + assert!(u == 0x9987, 0); + cursor::destroy_empty(cursor); + } + + #[test] + fun test_take_u32_be() { + let cursor = cursor::new(x"99876543"); + let u = bytes::take_u32_be(&mut cursor); + assert!(u == 0x99876543, 0); + cursor::destroy_empty(cursor); + } + + #[test] + fun test_take_u64_be() { + let cursor = cursor::new(x"1300000025000001"); + let u = bytes::take_u64_be(&mut cursor); + assert!(u == 0x1300000025000001, 0); + cursor::destroy_empty(cursor); + } + + #[test] + fun test_take_u128_be() { + let cursor = cursor::new(x"130209AB2500FA0113CD00AE25000001"); + let u = bytes::take_u128_be(&mut cursor); + assert!(u == 0x130209AB2500FA0113CD00AE25000001, 0); + cursor::destroy_empty(cursor); + } + + #[test] + fun test_to_bytes() { + let cursor = cursor::new(b"hello world"); + let hello = bytes::take_bytes(&mut cursor, 5); + bytes::take_u8(&mut cursor); + let world = bytes::take_bytes(&mut cursor, 5); + assert!(hello == b"hello", 0); + assert!(world == b"world", 0); + cursor::destroy_empty(cursor); + } + +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/utils/cursor.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/utils/cursor.move new file mode 100644 index 0000000000..73a96ebea0 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/utils/cursor.move @@ -0,0 +1,60 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a custom type that allows consuming a vector +/// incrementally for parsing operations. It has no drop ability, and the only +/// way to deallocate it is by calling the `destroy_empty` method, which will +/// fail if the whole input hasn't been consumed. +/// +/// This setup statically guarantees that the parsing methods consume the full +/// input. +module wormhole::cursor { + use std::vector::{Self}; + + /// Container for the underlying `vector` data to be consumed. + struct Cursor { + data: vector, + } + + /// Initialises a cursor from a vector. + public fun new(data: vector): Cursor { + // reverse the array so we have access to the first element easily + vector::reverse(&mut data); + Cursor { data } + } + + /// Retrieve underlying data. + public fun data(self: &Cursor): &vector { + &self.data + } + + /// Check whether the underlying data is empty. This method is useful for + /// iterating over a `Cursor` to exhaust its contents. + public fun is_empty(self: &Cursor): bool { + vector::is_empty(&self.data) + } + + /// Destroys an empty cursor. This method aborts if the cursor is not empty. + public fun destroy_empty(cursor: Cursor) { + let Cursor { data } = cursor; + vector::destroy_empty(data); + } + + /// Consumes the rest of the cursor (thus destroying it) and returns the + /// remaining bytes. + /// + /// NOTE: Only use this function if you intend to consume the rest of the + /// bytes. Since the result is a vector, which can be dropped, it is not + /// possible to statically guarantee that the rest will be used. + public fun take_rest(cursor: Cursor): vector { + let Cursor { data } = cursor; + // Because the data was reversed in initialization, we need to reverse + // again so it is in the same order as the original input. + vector::reverse(&mut data); + data + } + + /// Retrieve the first element of the cursor and advances it. + public fun poke(self: &mut Cursor): T { + vector::pop_back(&mut self.data) + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/utils/package_utils.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/utils/package_utils.move new file mode 100644 index 0000000000..12dcfde91a --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/utils/package_utils.move @@ -0,0 +1,422 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements utilities that supplement those methods implemented +/// in `sui::package`. +module wormhole::package_utils { + use std::type_name::{Self, TypeName}; + use sui::dynamic_field::{Self as field}; + use sui::object::{Self, ID, UID}; + use sui::package::{Self, UpgradeCap, UpgradeTicket, UpgradeReceipt}; + + use wormhole::bytes32::{Self, Bytes32}; + + /// `UpgradeCap` is not from the same package as `T`. + const E_INVALID_UPGRADE_CAP: u64 = 0; + /// Build is not current. + const E_NOT_CURRENT_VERSION: u64 = 1; + /// Old version to update from is wrong. + const E_INCORRECT_OLD_VERSION: u64 = 2; + /// Old and new are the same version. + const E_SAME_VERSION: u64 = 3; + /// Version types must come from this module. + const E_TYPE_NOT_ALLOWED: u64 = 4; + + /// Key for version dynamic fields. + struct CurrentVersion has store, drop, copy {} + + /// Key for dynamic field reflecting current package info. Its value is + /// `PackageInfo`. + struct CurrentPackage has store, drop, copy {} + struct PendingPackage has store, drop, copy {} + + struct PackageInfo has store, drop, copy { + package: ID, + digest: Bytes32 + } + + /// Retrieve current package ID, which should be the only one that anyone is + /// allowed to interact with. + public fun current_package(id: &UID): ID { + let info: &PackageInfo = field::borrow(id, CurrentPackage {}); + info.package + } + + /// Retrieve the build digest reflecting the current build. + public fun current_digest(id: &UID): Bytes32 { + let info: &PackageInfo = field::borrow(id, CurrentPackage {}); + info.digest + } + + /// Retrieve the upgraded package ID, which was taken from `UpgradeCap` + /// during `commit_upgrade`. + public fun committed_package(id: &UID): ID { + let info: &PackageInfo = field::borrow(id, PendingPackage {}); + info.package + } + + /// Retrieve the build digest of the latest upgrade, which was the same + /// digest used when `authorize_upgrade` is called. + public fun authorized_digest(id: &UID): Bytes32 { + let info: &PackageInfo = field::borrow(id, PendingPackage {}); + info.digest + } + + /// Convenience method that can be used with any package that requires + /// `UpgradeCap` to have certain preconditions before it is considered + /// belonging to `T` object's package. + public fun assert_package_upgrade_cap( + cap: &UpgradeCap, + expected_policy: u8, + expected_version: u64 + ) { + let expected_package = + sui::address::from_bytes( + sui::hex::decode( + std::ascii::into_bytes( + std::type_name::get_address( + &std::type_name::get() + ) + ) + ) + ); + let cap_package = + object::id_to_address(&package::upgrade_package(cap)); + assert!( + ( + cap_package == expected_package && + package::upgrade_policy(cap) == expected_policy && + package::version(cap) == expected_version + ), + E_INVALID_UPGRADE_CAP + ); + } + + /// Assert that the version type passed into this method is what exists + /// as the current version. + public fun assert_version( + id: &UID, + _version: Version + ) { + assert!( + field::exists_with_type( + id, + CurrentVersion {} + ), + E_NOT_CURRENT_VERSION + ) + } + + // Retrieve the `TypeName` of a given version. + public fun type_of_version(_version: Version): TypeName { + type_name::get() + } + + /// Initialize package info and set the initial version. This should be done + /// when a contract's state/storage shared object is created. + public fun init_package_info( + id: &mut UID, + version: InitialVersion, + upgrade_cap: &UpgradeCap + ) { + let package = package::upgrade_package(upgrade_cap); + field::add( + id, + CurrentPackage {}, + PackageInfo { package, digest: bytes32::default() } + ); + + // Set placeholders for pending package. We don't ever plan on removing + // this field. + field::add( + id, + PendingPackage {}, + PackageInfo { package, digest: bytes32::default() } + ); + + // Set the initial version. + field::add(id, CurrentVersion {}, version); + } + + /// Perform the version switchover and copy package info from pending to + /// current. This method should be executed after an upgrade (via a migrate + /// method) from the upgraded package. + /// + /// NOTE: This method can only be called once with the same version type + /// arguments. + public fun migrate_version< + Old: store + drop, + New: store + drop + >( + id: &mut UID, + old_version: Old, + new_version: New + ) { + update_version_type(id, old_version, new_version); + + update_package_info_from_pending(id); + } + + /// Helper for `sui::package::authorize_upgrade` to modify pending package + /// info by updating its digest. + /// + /// NOTE: This digest will be copied over when `migrate_version` is called. + public fun authorize_upgrade( + id: &mut UID, + upgrade_cap: &mut UpgradeCap, + package_digest: Bytes32 + ): UpgradeTicket { + let policy = package::upgrade_policy(upgrade_cap); + + // Manage saving the current digest. + set_authorized_digest(id, package_digest); + + // Finally authorize upgrade. + package::authorize_upgrade( + upgrade_cap, + policy, + bytes32::to_bytes(package_digest), + ) + } + + /// Helper for `sui::package::commit_upgrade` to modify pending package info + /// by updating its package ID with from what exists in the `UpgradeCap`. + /// This method returns the last package and the upgraded package IDs. + /// + /// NOTE: This package ID (second return value) will be copied over when + /// `migrate_version` is called. + public fun commit_upgrade( + id: &mut UID, + upgrade_cap: &mut UpgradeCap, + receipt: UpgradeReceipt + ): (ID, ID) { + // Uptick the upgrade cap version number using this receipt. + package::commit_upgrade(upgrade_cap, receipt); + + // Take the last pending package and replace it with the one now in + // the upgrade cap. + let previous_package = committed_package(id); + set_commited_package(id, upgrade_cap); + + // Return the package IDs. + (previous_package, committed_package(id)) + } + + fun set_commited_package(id: &mut UID, upgrade_cap: &UpgradeCap) { + let info: &mut PackageInfo = field::borrow_mut(id, PendingPackage {}); + info.package = package::upgrade_package(upgrade_cap); + } + + fun set_authorized_digest(id: &mut UID, digest: Bytes32) { + let info: &mut PackageInfo = field::borrow_mut(id, PendingPackage {}); + info.digest = digest; + } + + fun update_package_info_from_pending(id: &mut UID) { + let pending: PackageInfo = *field::borrow(id, PendingPackage {}); + *field::borrow_mut(id, CurrentPackage {}) = pending; + } + + /// Update from version n to n+1. We enforce that the versions be kept in + /// a module called "version_control". + fun update_version_type< + Old: store + drop, + New: store + drop + >( + id: &mut UID, + _old_version: Old, + new_version: New + ) { + use std::ascii::{into_bytes}; + + assert!( + field::exists_with_type(id, CurrentVersion {}), + E_INCORRECT_OLD_VERSION + ); + let _: Old = field::remove(id, CurrentVersion {}); + + let new_type = type_name::get(); + // Make sure the new type does not equal the old type, which means there + // is no protection against either build. + assert!(new_type != type_name::get(), E_SAME_VERSION); + + // Also make sure `New` originates from this module. + let module_name = into_bytes(type_name::get_module(&new_type)); + assert!(module_name == b"version_control", E_TYPE_NOT_ALLOWED); + + // Finally add the new version. + field::add(id, CurrentVersion {}, new_version); + } + + #[test_only] + public fun remove_package_info(id: &mut UID) { + let _: PackageInfo = field::remove(id, CurrentPackage {}); + let _: PackageInfo = field::remove(id, PendingPackage {}); + } + + #[test_only] + public fun init_version( + id: &mut UID, + version: Version + ) { + field::add(id, CurrentVersion {}, version); + } + + #[test_only] + public fun update_version_type_test_only< + Old: store + drop, + New: store + drop + >( + id: &mut UID, + old_version: Old, + new_version: New + ) { + update_version_type(id, old_version, new_version) + } +} + +#[test_only] +module wormhole::package_utils_tests { + use sui::object::{Self, UID}; + use sui::tx_context::{Self}; + + use wormhole::package_utils::{Self}; + use wormhole::version_control::{Self}; + + struct State has key { + id: UID + } + + struct V_DUMMY has store, drop, copy {} + + #[test] + fun test_assert_current() { + // Create dummy state. + let state = State { id: object::new(&mut tx_context::dummy()) }; + package_utils::init_version( + &mut state.id, + version_control::current_version() + ); + + package_utils::assert_version( + &state.id, + version_control::current_version() + ); + + // Clean up. + let State { id } = state; + object::delete(id); + } + + #[test] + #[expected_failure(abort_code = package_utils::E_INCORRECT_OLD_VERSION)] + fun test_cannot_update_incorrect_old_version() { + // Create dummy state. + let state = State { id: object::new(&mut tx_context::dummy()) }; + package_utils::init_version( + &mut state.id, + version_control::current_version() + ); + + package_utils::assert_version( + &state.id, + version_control::current_version() + ); + + // You shall not pass! + package_utils::update_version_type_test_only( + &mut state.id, + version_control::next_version(), + version_control::next_version() + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = package_utils::E_SAME_VERSION)] + fun test_cannot_update_same_version() { + // Create dummy state. + let state = State { id: object::new(&mut tx_context::dummy()) }; + package_utils::init_version( + &mut state.id, + version_control::current_version() + ); + + package_utils::assert_version( + &state.id, + version_control::current_version() + ); + + // You shall not pass! + package_utils::update_version_type_test_only( + &mut state.id, + version_control::current_version(), + version_control::current_version() + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_assert_current_outdated_version() { + // Create dummy state. + let state = State { id: object::new(&mut tx_context::dummy()) }; + package_utils::init_version( + &mut state.id, + version_control::current_version() + ); + + package_utils::assert_version( + &state.id, + version_control::current_version() + ); + + // Valid update. + package_utils::update_version_type_test_only( + &mut state.id, + version_control::current_version(), + version_control::next_version() + ); + + // You shall not pass! + package_utils::assert_version( + &state.id, + version_control::current_version() + ); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = package_utils::E_TYPE_NOT_ALLOWED)] + fun test_cannot_update_type_not_allowed() { + // Create dummy state. + let state = State { id: object::new(&mut tx_context::dummy()) }; + package_utils::init_version( + &mut state.id, + version_control::current_version() + ); + + package_utils::assert_version( + &state.id, + version_control::current_version() + ); + + // You shall not pass! + package_utils::update_version_type_test_only( + &mut state.id, + version_control::current_version(), + V_DUMMY {} + ); + + abort 42 + } + + #[test] + fun test_latest_version_different_from_previous() { + let prev = version_control::previous_version(); + let curr = version_control::current_version(); + assert!(package_utils::type_of_version(prev) != package_utils::type_of_version(curr), 0); + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/vaa.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/vaa.move new file mode 100644 index 0000000000..03528351d4 --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/vaa.move @@ -0,0 +1,782 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements a mechanism to parse and verify VAAs, which are +/// verified Wormhole messages (messages with Guardian signatures attesting to +/// its observation). Signatures on VAA are checked against an existing Guardian +/// set that exists in the `State` (see `wormhole::state`). +/// +/// A Wormhole integrator is discouraged from integrating `parse_and_verify` in +/// his contract. If there is a breaking change to the `vaa` module, Wormhole +/// will be upgraded to prevent previous build versions of this module to work. +/// If an integrator happened to use `parse_and_verify` in his contract, he will +/// need to be prepared to upgrade his contract to take the change (by building +/// with the latest package implementation). +/// +/// Instead, an integrator is encouraged to execute a transaction block, which +/// executes `parse_and_verify` from the latest Wormhole package ID and to +/// implement his methods that require redeeming a VAA to take `VAA` as an +/// argument. +/// +/// A good example of how this methodology is implemented is how the Token +/// Bridge contract redeems its VAAs. +module wormhole::vaa { + use std::option::{Self}; + use std::vector::{Self}; + use sui::clock::{Clock}; + use sui::hash::{keccak256}; + + use wormhole::bytes::{Self}; + use wormhole::bytes32::{Self, Bytes32}; + use wormhole::consumed_vaas::{Self, ConsumedVAAs}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self, ExternalAddress}; + use wormhole::guardian::{Self}; + use wormhole::guardian_set::{Self, GuardianSet}; + use wormhole::guardian_signature::{Self, GuardianSignature}; + use wormhole::state::{Self, State}; + + /// Incorrect VAA version. + const E_WRONG_VERSION: u64 = 0; + /// Not enough guardians attested to this Wormhole observation. + const E_NO_QUORUM: u64 = 1; + /// Signature does not match expected Guardian public key. + const E_INVALID_SIGNATURE: u64 = 2; + /// Prior guardian set is no longer valid. + const E_GUARDIAN_SET_EXPIRED: u64 = 3; + /// Guardian signature is encoded out of sequence. + const E_NON_INCREASING_SIGNERS: u64 = 4; + + const VERSION_VAA: u8 = 1; + + /// Container storing verified Wormhole message info. This struct also + /// caches the digest, which is a double Keccak256 hash of the message body. + struct VAA { + /// Guardian set index of Guardians that attested to observing the + /// Wormhole message. + guardian_set_index: u32, + /// Time when Wormhole message was emitted or observed. + timestamp: u32, + /// A.K.A. Batch ID. + nonce: u32, + /// Wormhole chain ID from which network the message originated from. + emitter_chain: u16, + /// Address of contract (standardized to 32 bytes) that produced the + /// message. + emitter_address: ExternalAddress, + /// Sequence number of emitter's Wormhole message. + sequence: u64, + /// A.K.A. Finality. + consistency_level: u8, + /// Arbitrary payload encoding data relevant to receiver. + payload: vector, + + /// Double Keccak256 hash of message body. + digest: Bytes32 + } + + public fun guardian_set_index(self: &VAA): u32 { + self.guardian_set_index + } + + public fun timestamp(self: &VAA): u32 { + self.timestamp + } + + public fun nonce(self: &VAA): u32 { + self.nonce + } + + public fun batch_id(self: &VAA): u32 { + nonce(self) + } + + public fun payload(self: &VAA): vector { + self.payload + } + + public fun digest(self: &VAA): Bytes32 { + self.digest + } + + public fun emitter_chain(self: &VAA): u16 { + self.emitter_chain + } + + public fun emitter_address(self: &VAA): ExternalAddress { + self.emitter_address + } + + public fun emitter_info(self: &VAA): (u16, ExternalAddress, u64) { + (self.emitter_chain, self.emitter_address, self.sequence) + } + + public fun sequence(self: &VAA): u64 { + self.sequence + } + + public fun consistency_level(self: &VAA): u8 { + self.consistency_level + } + + public fun finality(self: &VAA): u8 { + consistency_level(self) + } + + /// Destroy the `VAA` and take the Wormhole message payload. + public fun take_payload(vaa: VAA): vector { + let (_, _, payload) = take_emitter_info_and_payload(vaa); + + payload + } + + /// Destroy the `VAA` and take emitter info (chain and address) and Wormhole + /// message payload. + public fun take_emitter_info_and_payload( + vaa: VAA + ): (u16, ExternalAddress, vector) { + let VAA { + guardian_set_index: _, + timestamp: _, + nonce: _, + emitter_chain, + emitter_address, + sequence: _, + consistency_level: _, + digest: _, + payload, + } = vaa; + (emitter_chain, emitter_address, payload) + } + + /// Parses and verifies the signatures of a VAA. + /// + /// NOTE: This is the only public function that returns a VAA, and it should + /// be kept that way. This ensures that if an external module receives a + /// `VAA`, it has been verified. + public fun parse_and_verify( + wormhole_state: &State, + buf: vector, + the_clock: &Clock + ): VAA { + state::assert_latest_only(wormhole_state); + + // Deserialize VAA buffer (and return `VAA` after verifying signatures). + let (signatures, vaa) = parse(buf); + + // Fetch the guardian set which this VAA was supposedly signed with and + // verify signatures using guardian set. + verify_signatures( + state::guardian_set_at( + wormhole_state, + vaa.guardian_set_index + ), + signatures, + bytes32::to_bytes(compute_message_hash(&vaa)), + the_clock + ); + + // Done. + vaa + } + + public fun consume(consumed: &mut ConsumedVAAs, parsed: &VAA) { + consumed_vaas::consume(consumed, digest(parsed)) + } + + public fun compute_message_hash(parsed: &VAA): Bytes32 { + let buf = vector::empty(); + + bytes::push_u32_be(&mut buf, parsed.timestamp); + bytes::push_u32_be(&mut buf, parsed.nonce); + bytes::push_u16_be(&mut buf, parsed.emitter_chain); + vector::append( + &mut buf, + external_address::to_bytes(parsed.emitter_address) + ); + bytes::push_u64_be(&mut buf, parsed.sequence); + bytes::push_u8(&mut buf, parsed.consistency_level); + vector::append(&mut buf, parsed.payload); + + // Return hash. + bytes32::new(keccak256(&buf)) + } + + /// Parses a VAA. + /// + /// NOTE: This method does NOT perform any verification. This ensures the + /// invariant that if an external module receives a `VAA` object, its + /// signatures must have been verified, because the only public function + /// that returns a `VAA` is `parse_and_verify`. + fun parse(buf: vector): (vector, VAA) { + let cur = cursor::new(buf); + + // Check VAA version. + assert!( + bytes::take_u8(&mut cur) == VERSION_VAA, + E_WRONG_VERSION + ); + + let guardian_set_index = bytes::take_u32_be(&mut cur); + + // Deserialize guardian signatures. + let num_signatures = bytes::take_u8(&mut cur); + let signatures = vector::empty(); + let i = 0; + while (i < num_signatures) { + let guardian_index = bytes::take_u8(&mut cur); + let r = bytes32::take_bytes(&mut cur); + let s = bytes32::take_bytes(&mut cur); + let recovery_id = bytes::take_u8(&mut cur); + vector::push_back( + &mut signatures, + guardian_signature::new(r, s, recovery_id, guardian_index) + ); + i = i + 1; + }; + + // Deserialize message body. + let body_buf = cursor::take_rest(cur); + + let cur = cursor::new(body_buf); + let timestamp = bytes::take_u32_be(&mut cur); + let nonce = bytes::take_u32_be(&mut cur); + let emitter_chain = bytes::take_u16_be(&mut cur); + let emitter_address = external_address::take_bytes(&mut cur); + let sequence = bytes::take_u64_be(&mut cur); + let consistency_level = bytes::take_u8(&mut cur); + let payload = cursor::take_rest(cur); + + let parsed = VAA { + guardian_set_index, + timestamp, + nonce, + emitter_chain, + emitter_address, + sequence, + consistency_level, + digest: double_keccak256(body_buf), + payload, + }; + + (signatures, parsed) + } + + fun double_keccak256(buf: vector): Bytes32 { + use sui::hash::{keccak256}; + + bytes32::new(keccak256(&keccak256(&buf))) + } + + /// Using the Guardian signatures deserialized from VAA, verify that all of + /// the Guardian public keys are recovered using these signatures and the + /// VAA message body as the message used to produce these signatures. + /// + /// We are careful to only allow `wormhole:vaa` to control the hash that + /// gets used in the `ecdsa_k1` module by computing the hash after + /// deserializing the VAA message body. Even though `ecdsa_k1` hashes a + /// raw message (as of version 0.28), the "raw message" in this case is a + /// single keccak256 hash of the VAA message body. + fun verify_signatures( + set: &GuardianSet, + signatures: vector, + message_hash: vector, + the_clock: &Clock + ) { + // Guardian set must be active (not expired). + assert!( + guardian_set::is_active(set, the_clock), + E_GUARDIAN_SET_EXPIRED + ); + + // Number of signatures must be at least quorum. + assert!( + vector::length(&signatures) >= guardian_set::quorum(set), + E_NO_QUORUM + ); + + // Drain `Cursor` by checking each signature. + let cur = cursor::new(signatures); + let last_guardian_index = option::none(); + while (!cursor::is_empty(&cur)) { + let signature = cursor::poke(&mut cur); + let guardian_index = guardian_signature::index_as_u64(&signature); + + // Ensure that the provided signatures are strictly increasing. + // This check makes sure that no duplicate signers occur. The + // increasing order is guaranteed by the guardians, or can always be + // reordered by the client. + assert!( + ( + option::is_none(&last_guardian_index) || + guardian_index > *option::borrow(&last_guardian_index) + ), + E_NON_INCREASING_SIGNERS + ); + + // If the guardian pubkey cannot be recovered using the signature + // and message hash, revert. + assert!( + guardian::verify( + guardian_set::guardian_at(set, guardian_index), + signature, + message_hash + ), + E_INVALID_SIGNATURE + ); + + // Continue. + option::swap_or_fill(&mut last_guardian_index, guardian_index); + }; + + // Done. + cursor::destroy_empty(cur); + } + + #[test_only] + public fun parse_test_only( + buf: vector + ): (vector, VAA) { + parse(buf) + } + + #[test_only] + public fun destroy(vaa: VAA) { + take_payload(vaa); + } + + #[test_only] + public fun peel_payload_from_vaa(buf: &vector): vector { + // Just make sure that we are passing version 1 VAAs to this method. + assert!(*vector::borrow(buf, 0) == VERSION_VAA, E_WRONG_VERSION); + + // Find the location of the payload. + let num_signatures = (*vector::borrow(buf, 5) as u64); + let i = 57 + num_signatures * 66; + + // Push the payload bytes to `out` and return. + let out = vector::empty(); + let len = vector::length(buf); + while (i < len) { + vector::push_back(&mut out, *vector::borrow(buf, i)); + i = i + 1; + }; + + // Return the payload. + out + } +} + +#[test_only] +module wormhole::vaa_tests { + use std::vector::{Self}; + use sui::test_scenario::{Self}; + + use wormhole::bytes32::{Self}; + use wormhole::cursor::{Self}; + use wormhole::external_address::{Self}; + use wormhole::guardian_signature::{Self}; + use wormhole::state::{Self}; + use wormhole::vaa::{Self}; + use wormhole::version_control::{Self}; + use wormhole::wormhole_scenario::{ + guardians, + person, + return_clock, + return_state, + set_up_wormhole_with_guardians, + take_clock, + take_state + //upgrade_wormhole + }; + + const VAA_1: vector = + x"01000000000d009bafff633087a9587d9afb6d29bd74a3483b7a8d5619323a416fe9ca43b482cd5526fabe953157cfd42eea9ffa544babc0f3a025a8a6159217b96fc9ff586d560002c9367884940a43a1a4d86531ea33ccb41e52bd7d1679c106fdff756f3da2ca743f7c181fcf40d19151d0a8397335c1b71709279b6e4fa97b6e3de90824e841c801035a493b65bf12ab9b98aa4db3bfcb73df20ab854d8e5998a1552f3b3e57ea7cd3546187c62cd450d12d430cae0fb48124ae68034dae602fa3e2232b55257961f90104758e265101353923661f6df67cec3c38528ed1b68825099b5bb2ce3fb2e735c5073d90223bebd00cc10406a60413a6089b5fb9acee0a1b04a63a8d7db24c0bbc000587777306dd174e266c313f711e881086355b6ce66cf2bf1f5da58273a10be77813b5ffcafc1ba6b83645e326a7c1a3751496f279ba307a6cd554f2709c2f1eda0108ed23ba8264146c3e3cc0601c93260c25058bcdd25213a7834e51679afdc4b50104e3f3a3079ba45115e703096c7e0700354cd48348bbf686dcbc58be896c35a20009c2352cb46ef1d2ef9e185764650403aee87a1be071555b31cdcee0c346991da858defb8d5e164a293ce4377b54fc74b65e3acbdedcbb53c2bcc2688a0b5bd1c9010ae470b1573989f387f7c54a86325cc05978bbcbc13267e90e2fa2efb0e18bccb772252bd6d13ebf908f7f3f2caf20a45c17dec7168122a2535ea93d300fae7063000ba0e8770298d4e3567488f455455a33f1e723e1e629ba4f87928016aeaa5875561ec38bde5d934389dc657d80a927cd9d06a9d9c7ce910c98d77a576e3f31735c000eeeedc956cff4489ac55b52ca38233cdc11e88767e5cc82f664bd1d7c28dfb5a12d7d17620725aae08e499b021200919f42c50c05916cf425dcd6e59f24b4b233000f18d447c9608a076c066b30ee770910e3c133087d33e329ad0101f08f88d88e142623df87aa3842edcf34e10fd36271b49f7af73ff2a7bcf4a65a4306d59586f20111905fc99dc650d9b1b33c313e9b31dfdbc85ce57e9f31abc4841d5791a239f20e5f28e4e612db96aee2f49ae712f724466007aaf27309d0385005fe0264d33dd100127b46f2fbbbf12efb10c2e662b4449de404f6a408ad7f38c7ea40a46300930e9a3b1e02ce00b97e33fa8a87221c1fd9064ce966dc4772658b98f2ec1e28d13e7400000023280000000c002adeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef000000000000092a20416c6c20796f75722062617365206172652062656c6f6e6720746f207573"; + const VAA_DOUBLE_SIGNED: vector = + x"01000000000d009bafff633087a9587d9afb6d29bd74a3483b7a8d5619323a416fe9ca43b482cd5526fabe953157cfd42eea9ffa544babc0f3a025a8a6159217b96fc9ff586d560002c9367884940a43a1a4d86531ea33ccb41e52bd7d1679c106fdff756f3da2ca743f7c181fcf40d19151d0a8397335c1b71709279b6e4fa97b6e3de90824e841c80102c9367884940a43a1a4d86531ea33ccb41e52bd7d1679c106fdff756f3da2ca743f7c181fcf40d19151d0a8397335c1b71709279b6e4fa97b6e3de90824e841c801035a493b65bf12ab9b98aa4db3bfcb73df20ab854d8e5998a1552f3b3e57ea7cd3546187c62cd450d12d430cae0fb48124ae68034dae602fa3e2232b55257961f90104758e265101353923661f6df67cec3c38528ed1b68825099b5bb2ce3fb2e735c5073d90223bebd00cc10406a60413a6089b5fb9acee0a1b04a63a8d7db24c0bbc000587777306dd174e266c313f711e881086355b6ce66cf2bf1f5da58273a10be77813b5ffcafc1ba6b83645e326a7c1a3751496f279ba307a6cd554f2709c2f1eda0108ed23ba8264146c3e3cc0601c93260c25058bcdd25213a7834e51679afdc4b50104e3f3a3079ba45115e703096c7e0700354cd48348bbf686dcbc58be896c35a20009c2352cb46ef1d2ef9e185764650403aee87a1be071555b31cdcee0c346991da858defb8d5e164a293ce4377b54fc74b65e3acbdedcbb53c2bcc2688a0b5bd1c9010ae470b1573989f387f7c54a86325cc05978bbcbc13267e90e2fa2efb0e18bccb772252bd6d13ebf908f7f3f2caf20a45c17dec7168122a2535ea93d300fae7063000ba0e8770298d4e3567488f455455a33f1e723e1e629ba4f87928016aeaa5875561ec38bde5d934389dc657d80a927cd9d06a9d9c7ce910c98d77a576e3f31735c000f18d447c9608a076c066b30ee770910e3c133087d33e329ad0101f08f88d88e142623df87aa3842edcf34e10fd36271b49f7af73ff2a7bcf4a65a4306d59586f20111905fc99dc650d9b1b33c313e9b31dfdbc85ce57e9f31abc4841d5791a239f20e5f28e4e612db96aee2f49ae712f724466007aaf27309d0385005fe0264d33dd100127b46f2fbbbf12efb10c2e662b4449de404f6a408ad7f38c7ea40a46300930e9a3b1e02ce00b97e33fa8a87221c1fd9064ce966dc4772658b98f2ec1e28d13e7400000023280000000c002adeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef000000000000092a20416c6c20796f75722062617365206172652062656c6f6e6720746f207573"; + const VAA_NO_QUORUM: vector = + x"01000000000c009bafff633087a9587d9afb6d29bd74a3483b7a8d5619323a416fe9ca43b482cd5526fabe953157cfd42eea9ffa544babc0f3a025a8a6159217b96fc9ff586d560002c9367884940a43a1a4d86531ea33ccb41e52bd7d1679c106fdff756f3da2ca743f7c181fcf40d19151d0a8397335c1b71709279b6e4fa97b6e3de90824e841c801035a493b65bf12ab9b98aa4db3bfcb73df20ab854d8e5998a1552f3b3e57ea7cd3546187c62cd450d12d430cae0fb48124ae68034dae602fa3e2232b55257961f90104758e265101353923661f6df67cec3c38528ed1b68825099b5bb2ce3fb2e735c5073d90223bebd00cc10406a60413a6089b5fb9acee0a1b04a63a8d7db24c0bbc000587777306dd174e266c313f711e881086355b6ce66cf2bf1f5da58273a10be77813b5ffcafc1ba6b83645e326a7c1a3751496f279ba307a6cd554f2709c2f1eda0108ed23ba8264146c3e3cc0601c93260c25058bcdd25213a7834e51679afdc4b50104e3f3a3079ba45115e703096c7e0700354cd48348bbf686dcbc58be896c35a20009c2352cb46ef1d2ef9e185764650403aee87a1be071555b31cdcee0c346991da858defb8d5e164a293ce4377b54fc74b65e3acbdedcbb53c2bcc2688a0b5bd1c9010ae470b1573989f387f7c54a86325cc05978bbcbc13267e90e2fa2efb0e18bccb772252bd6d13ebf908f7f3f2caf20a45c17dec7168122a2535ea93d300fae7063000ba0e8770298d4e3567488f455455a33f1e723e1e629ba4f87928016aeaa5875561ec38bde5d934389dc657d80a927cd9d06a9d9c7ce910c98d77a576e3f31735c000f18d447c9608a076c066b30ee770910e3c133087d33e329ad0101f08f88d88e142623df87aa3842edcf34e10fd36271b49f7af73ff2a7bcf4a65a4306d59586f20111905fc99dc650d9b1b33c313e9b31dfdbc85ce57e9f31abc4841d5791a239f20e5f28e4e612db96aee2f49ae712f724466007aaf27309d0385005fe0264d33dd100127b46f2fbbbf12efb10c2e662b4449de404f6a408ad7f38c7ea40a46300930e9a3b1e02ce00b97e33fa8a87221c1fd9064ce966dc4772658b98f2ec1e28d13e7400000023280000000c002adeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef000000000000092a20416c6c20796f75722062617365206172652062656c6f6e6720746f207573"; + + #[test] + fun test_parse() { + let (signatures, parsed) = vaa::parse_test_only(VAA_1); + + let expected_signatures = + vector[ + guardian_signature::new( + bytes32::new( + x"9bafff633087a9587d9afb6d29bd74a3483b7a8d5619323a416fe9ca43b482cd" + ), // r + bytes32::new( + x"5526fabe953157cfd42eea9ffa544babc0f3a025a8a6159217b96fc9ff586d56" + ), // s + 0, // recovery_id + 0 // index + ), + guardian_signature::new( + bytes32::new( + x"c9367884940a43a1a4d86531ea33ccb41e52bd7d1679c106fdff756f3da2ca74" + ), // r + bytes32::new( + x"3f7c181fcf40d19151d0a8397335c1b71709279b6e4fa97b6e3de90824e841c8" + ), // s + 1, // recovery_id + 2 // index + ), + guardian_signature::new( + bytes32::new( + x"5a493b65bf12ab9b98aa4db3bfcb73df20ab854d8e5998a1552f3b3e57ea7cd3" + ), // r + bytes32::new( + x"546187c62cd450d12d430cae0fb48124ae68034dae602fa3e2232b55257961f9" + ), // s + 1, // recovery_id + 3 // index + ), + guardian_signature::new( + bytes32::new( + x"758e265101353923661f6df67cec3c38528ed1b68825099b5bb2ce3fb2e735c5" + ), // r + bytes32::new( + x"073d90223bebd00cc10406a60413a6089b5fb9acee0a1b04a63a8d7db24c0bbc" + ), // s + 0, // recovery_id + 4 // index + ), + guardian_signature::new( + bytes32::new( + x"87777306dd174e266c313f711e881086355b6ce66cf2bf1f5da58273a10be778" + ), // r + bytes32::new( + x"13b5ffcafc1ba6b83645e326a7c1a3751496f279ba307a6cd554f2709c2f1eda" + ), // s + 1, // recovery_id + 5 // index + ), + guardian_signature::new( + bytes32::new( + x"ed23ba8264146c3e3cc0601c93260c25058bcdd25213a7834e51679afdc4b501" + ), // r + bytes32::new( + x"04e3f3a3079ba45115e703096c7e0700354cd48348bbf686dcbc58be896c35a2" + ), // s + 0, // recovery_id + 8 // index + ), + guardian_signature::new( + bytes32::new( + x"c2352cb46ef1d2ef9e185764650403aee87a1be071555b31cdcee0c346991da8" + ), // r + bytes32::new( + x"58defb8d5e164a293ce4377b54fc74b65e3acbdedcbb53c2bcc2688a0b5bd1c9" + ), // s + 1, // recovery_id + 9 // index + ), + guardian_signature::new( + bytes32::new( + x"e470b1573989f387f7c54a86325cc05978bbcbc13267e90e2fa2efb0e18bccb7" + ), // r + bytes32::new( + x"72252bd6d13ebf908f7f3f2caf20a45c17dec7168122a2535ea93d300fae7063" + ), // s + 0, // recovery_id + 10 // index + ), + guardian_signature::new( + bytes32::new( + x"a0e8770298d4e3567488f455455a33f1e723e1e629ba4f87928016aeaa587556" + ), // r + bytes32::new( + x"1ec38bde5d934389dc657d80a927cd9d06a9d9c7ce910c98d77a576e3f31735c" + ), // s + 0, // recovery_id + 11 // index + ), + guardian_signature::new( + bytes32::new( + x"eeedc956cff4489ac55b52ca38233cdc11e88767e5cc82f664bd1d7c28dfb5a1" + ), // r + bytes32::new( + x"2d7d17620725aae08e499b021200919f42c50c05916cf425dcd6e59f24b4b233" + ), // s + 0, // recovery_id + 14 // index + ), + guardian_signature::new( + bytes32::new( + x"18d447c9608a076c066b30ee770910e3c133087d33e329ad0101f08f88d88e14" + ), // r + bytes32::new( + x"2623df87aa3842edcf34e10fd36271b49f7af73ff2a7bcf4a65a4306d59586f2" + ), // s + 1, // recovery_id + 15 // index + ), + guardian_signature::new( + bytes32::new( + x"905fc99dc650d9b1b33c313e9b31dfdbc85ce57e9f31abc4841d5791a239f20e" + ), // r + bytes32::new( + x"5f28e4e612db96aee2f49ae712f724466007aaf27309d0385005fe0264d33dd1" + ), // s + 0, // recovery_id + 17 // index + ), + guardian_signature::new( + bytes32::new( + x"7b46f2fbbbf12efb10c2e662b4449de404f6a408ad7f38c7ea40a46300930e9a" + ), // r + bytes32::new( + x"3b1e02ce00b97e33fa8a87221c1fd9064ce966dc4772658b98f2ec1e28d13e74" + ), // s + 0, // recovery_id + 18 // index + ) + ]; + assert!( + vector::length(&signatures) == vector::length(&expected_signatures), + 0 + ); + let left = cursor::new(signatures); + let right = cursor::new(expected_signatures); + while (!cursor::is_empty(&left)) { + assert!(cursor::poke(&mut left) == cursor::poke(&mut right), 0); + }; + cursor::destroy_empty(left); + cursor::destroy_empty(right); + + assert!(vaa::guardian_set_index(&parsed) == 0, 0); + assert!(vaa::timestamp(&parsed) == 9000, 0); + + let expected_batch_id = 12; + assert!(vaa::batch_id(&parsed) == expected_batch_id, 0); + assert!(vaa::nonce(&parsed) == expected_batch_id, 0); + + assert!(vaa::emitter_chain(&parsed) == 42, 0); + + let expected_emitter_address = + external_address::from_address( + @0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef + ); + assert!(vaa::emitter_address(&parsed) == expected_emitter_address, 0); + assert!(vaa::sequence(&parsed) == 2346, 0); + + let expected_finality = 32; + assert!(vaa::finality(&parsed) == expected_finality, 0); + assert!(vaa::consistency_level(&parsed) == expected_finality, 0); + + // The message Wormhole guardians sign is a hash of the actual message + // body. So the hash we need to check against is keccak256 of this + // message. + let body_buf = { + use wormhole::bytes::{Self}; + + let buf = vector::empty(); + bytes::push_u32_be(&mut buf, vaa::timestamp(&parsed)); + bytes::push_u32_be(&mut buf, vaa::nonce(&parsed)); + bytes::push_u16_be(&mut buf, vaa::emitter_chain(&parsed)); + vector::append( + &mut buf, + external_address::to_bytes(vaa::emitter_address(&parsed)) + ); + bytes::push_u64_be(&mut buf, vaa::sequence(&parsed)); + bytes::push_u8(&mut buf, vaa::consistency_level(&parsed)); + vector::append(&mut buf, vaa::payload(&parsed)); + + buf + }; + + let expected_message_hash = + bytes32::new(sui::hash::keccak256(&body_buf)); + assert!(vaa::compute_message_hash(&parsed) == expected_message_hash, 0); + + let expected_digest = + bytes32::new( + sui::hash::keccak256(&sui::hash::keccak256(&body_buf)) + ); + assert!(vaa::digest(&parsed) == expected_digest, 0); + + assert!( + vaa::take_payload(parsed) == b"All your base are belong to us", + 0 + ); + } + + #[test] + fun test_parse_and_verify() { + // Testing this method. + use wormhole::vaa::{parse_and_verify}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole with 19 guardians. + let wormhole_fee = 350; + set_up_wormhole_with_guardians(scenario, wormhole_fee, guardians()); + + // Prepare test to execute `parse_and_verify`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + let verified_vaa = parse_and_verify(&worm_state, VAA_1, &the_clock); + + // We verified all parsed output in `test_parse`. But in destroying the + // parsed VAA, we will check the payload for the heck of it. + assert!( + vaa::take_payload(verified_vaa) == b"All your base are belong to us", + 0 + ); + + // Clean up. + return_state(worm_state); + return_clock(the_clock); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = vaa::E_NO_QUORUM)] + fun test_cannot_parse_and_verify_without_quorum() { + // Testing this method. + use wormhole::vaa::{parse_and_verify}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole with 19 guardians. + let wormhole_fee = 350; + set_up_wormhole_with_guardians(scenario, wormhole_fee, guardians()); + + // Prepare test to execute `parse_and_verify`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // You shall not pass! + let verified_vaa = parse_and_verify(&worm_state, VAA_NO_QUORUM, &the_clock); + + // Clean up. + vaa::destroy(verified_vaa); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = vaa::E_NON_INCREASING_SIGNERS)] + fun test_cannot_parse_and_verify_non_increasing() { + // Testing this method. + use wormhole::vaa::{parse_and_verify}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole with 19 guardians. + let wormhole_fee = 350; + set_up_wormhole_with_guardians(scenario, wormhole_fee, guardians()); + + // Prepare test to execute `parse_and_verify`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // You shall not pass! + let verified_vaa = + parse_and_verify(&worm_state, VAA_DOUBLE_SIGNED, &the_clock); + + // Clean up. + vaa::destroy(verified_vaa); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = vaa::E_INVALID_SIGNATURE)] + fun test_cannot_parse_and_verify_invalid_signature() { + // Testing this method. + use wormhole::vaa::{parse_and_verify}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole with 19 guardians. But reverse the order so the + // signatures will not match. + let initial_guardians = guardians(); + std::vector::reverse(&mut initial_guardians); + + let wormhole_fee = 350; + set_up_wormhole_with_guardians( + scenario, + wormhole_fee, + initial_guardians + ); + + // Prepare test to execute `parse_and_verify`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // You shall not pass! + let verified_vaa = parse_and_verify(&worm_state, VAA_1, &the_clock); + + // Clean up. + vaa::destroy(verified_vaa); + + abort 42 + } + + #[test] + #[expected_failure(abort_code = wormhole::package_utils::E_NOT_CURRENT_VERSION)] + fun test_cannot_parse_and_verify_outdated_version() { + // Testing this method. + use wormhole::vaa::{parse_and_verify}; + + // Set up. + let caller = person(); + let my_scenario = test_scenario::begin(caller); + let scenario = &mut my_scenario; + + // Initialize Wormhole with 19 guardians. + let wormhole_fee = 350; + set_up_wormhole_with_guardians(scenario, wormhole_fee, guardians()); + + // Prepare test to execute `parse_and_verify`. + test_scenario::next_tx(scenario, caller); + + let worm_state = take_state(scenario); + let the_clock = take_clock(scenario); + + // Conveniently roll version back. + state::reverse_migrate_version(&mut worm_state); + + // Simulate executing with an outdated build by upticking the minimum + // required version for `publish_message` to something greater than + // this build. + state::migrate_version_test_only( + &mut worm_state, + version_control::previous_version_test_only(), + version_control::next_version() + ); + + // You shall not pass! + let verified_vaa = parse_and_verify(&worm_state, VAA_1, &the_clock); + + // Clean up. + vaa::destroy(verified_vaa); + + abort 42 + } +} diff --git a/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/version_control.move b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/version_control.move new file mode 100644 index 0000000000..13ee6106df --- /dev/null +++ b/target_chains/iota/vendor/wormhole_movement_m2_devnet/wormhole/sources/version_control.move @@ -0,0 +1,70 @@ +// SPDX-License-Identifier: Apache 2 + +/// This module implements dynamic field keys as empty structs. These keys are +/// used to determine the latest version for this build. If the current version +/// is not this build's, then paths through the `state` module will abort. +/// +/// See `wormhole::state` and `wormhole::package_utils` for more info. +module wormhole::version_control { + //////////////////////////////////////////////////////////////////////////// + // + // Hard-coded Version Control + // + // Before upgrading, please set the types for `current_version` and + // `previous_version` to match the correct types (current being the latest + // version reflecting this build). + // + //////////////////////////////////////////////////////////////////////////// + + public(friend) fun current_version(): V__0_2_0 { + V__0_2_0 {} + } + + public(friend) fun previous_version(): V__DUMMY { + V__DUMMY {} + } + + #[test_only] + public fun previous_version_test_only(): V__DUMMY { + previous_version() + } + + //////////////////////////////////////////////////////////////////////////// + // + // Change Log + // + // Please write release notes as doc strings for each version struct. These + // notes will be our attempt at tracking upgrades. Wish us luck. + // + //////////////////////////////////////////////////////////////////////////// + + /// First published package on Sui mainnet. + struct V__0_2_0 has store, drop, copy {} + + // Dummy. + struct V__DUMMY has store, drop, copy {} + + //////////////////////////////////////////////////////////////////////////// + // + // Implementation and Test-Only Methods + // + //////////////////////////////////////////////////////////////////////////// + + friend wormhole::state; + + #[test_only] + friend wormhole::package_utils_tests; + + #[test_only] + public fun dummy(): V__DUMMY { + V__DUMMY {} + } + + #[test_only] + struct V__MIGRATED has store, drop, copy {} + + #[test_only] + public fun next_version(): V__MIGRATED { + V__MIGRATED {} + } +} diff --git a/target_chains/sui/contracts/Move.lock b/target_chains/sui/contracts/Move.lock index 4d695c4552..c1788d4ba6 100644 --- a/target_chains/sui/contracts/Move.lock +++ b/target_chains/sui/contracts/Move.lock @@ -2,35 +2,35 @@ [move] version = 0 -manifest_digest = "915D6459031D76A0618631BDF08328171A3494876C5E17735BCBFF462BEDF464" +manifest_digest = "320300697C11C4D84BF6ED32C1DB48A4EE830B6B44F4DFDA4E89345875C5EA11" deps_digest = "3C4103934B1E040BB6B23F1D610B4EF9F2F1166A50A104EADCF77467C004C600" dependencies = [ - { name = "Iota" }, + { name = "Sui" }, { name = "Wormhole" }, ] [[move.package]] -name = "Iota" -source = { git = "https://github.com/iotaledger/iota.git", rev = "751c23caf24efd071463b9ffd07eabcb15f44f31", subdir = "crates/iota-framework/packages/iota-framework" } +name = "MoveStdlib" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/move-stdlib" } + +[[move.package]] +name = "Sui" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "041c5f2bae2fe52079e44b70514333532d69f4e6", subdir = "crates/sui-framework/packages/sui-framework" } dependencies = [ { name = "MoveStdlib" }, ] -[[move.package]] -name = "MoveStdlib" -source = { git = "https://github.com/iotaledger/iota.git", rev = "751c23caf24efd071463b9ffd07eabcb15f44f31", subdir = "crates/iota-framework/packages/move-stdlib" } - [[move.package]] name = "Wormhole" -source = { local = "../vendor/wormhole_iota_testnet/wormhole" } +source = { git = "https://github.com/wormhole-foundation/wormhole.git", rev = "82d82bffd5a8566e4b5d94be4e4678ad55ab1f4f", subdir = "sui/wormhole" } dependencies = [ - { name = "Iota" }, + { name = "Sui" }, ] [move.toolchain-version] -compiler-version = "0.9.2-rc" -edition = "2024.beta" -flavor = "iota" +compiler-version = "1.27.2" +edition = "legacy" +flavor = "sui" diff --git a/target_chains/sui/contracts/Move.toml b/target_chains/sui/contracts/Move.toml index e21819c7b3..fabdea676e 100644 --- a/target_chains/sui/contracts/Move.toml +++ b/target_chains/sui/contracts/Move.toml @@ -1,15 +1,17 @@ [package] name = "Pyth" version = "0.0.2" -published-at = "0x23994dd119480ea614f7623520337058dca913cb1bb6e5d8d51c7b067d3ca3bb" -[dependencies.Iota] -git = "https://github.com/iotaledger/iota.git" -subdir = "crates/iota-framework/packages/iota-framework" -rev = "751c23caf24efd071463b9ffd07eabcb15f44f31" +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "041c5f2bae2fe52079e44b70514333532d69f4e6" [dependencies.Wormhole] -local = "../vendor/wormhole_iota_testnet/wormhole" +git = "https://github.com/wormhole-foundation/wormhole.git" +subdir = "sui/wormhole" +rev = "82d82bffd5a8566e4b5d94be4e4678ad55ab1f4f" [addresses] -pyth = "0x23994dd119480ea614f7623520337058dca913cb1bb6e5d8d51c7b067d3ca3bb" +pyth = "0x00b53b0f4174108627fbee72e2498b58d6a2714cded53fac537034c220d26302" +wormhole = "0x5306f64e312b581766351c07af79c72fcb1cd25147157fdc2f8ad76de9a3fb6a" diff --git a/target_chains/sui/contracts/sources/batch_price_attestation.move b/target_chains/sui/contracts/sources/batch_price_attestation.move index 461c8daac3..4d44703c09 100644 --- a/target_chains/sui/contracts/sources/batch_price_attestation.move +++ b/target_chains/sui/contracts/sources/batch_price_attestation.move @@ -1,6 +1,6 @@ module pyth::batch_price_attestation { use std::vector::{Self}; - use iota::clock::{Self, Clock}; + use sui::clock::{Self, Clock}; use pyth::price_feed::{Self}; use pyth::price_info::{Self, PriceInfo}; @@ -164,7 +164,7 @@ module pyth::batch_price_attestation { #[test] #[expected_failure] fun test_deserialize_batch_price_attestation_invalid_magic() { - use iota::test_scenario::{Self, ctx}; + use sui::test_scenario::{Self, ctx}; let test = test_scenario::begin(@0x1234); let test_clock = clock::create_for_testing(ctx(&mut test)); // A batch price attestation with a magic number of 0x50325749 @@ -176,7 +176,7 @@ module pyth::batch_price_attestation { #[test] fun test_deserialize_batch_price_attestation() { - use iota::test_scenario::{Self, ctx}; + use sui::test_scenario::{Self, ctx}; // Set the arrival time let test = test_scenario::begin(@0x1234); let test_clock = clock::create_for_testing(ctx(&mut test)); diff --git a/target_chains/sui/contracts/sources/data_source.move b/target_chains/sui/contracts/sources/data_source.move index 2b7e4a56e9..d4814cd554 100644 --- a/target_chains/sui/contracts/sources/data_source.move +++ b/target_chains/sui/contracts/sources/data_source.move @@ -1,7 +1,7 @@ module pyth::data_source { - use iota::dynamic_field::{Self}; - use iota::object::{UID}; - use iota::tx_context::{TxContext}; + use sui::dynamic_field::{Self}; + use sui::object::{UID}; + use sui::tx_context::{TxContext}; use pyth::set::{Self}; diff --git a/target_chains/sui/contracts/sources/event.move b/target_chains/sui/contracts/sources/event.move index ab23be344d..a40c5d218b 100644 --- a/target_chains/sui/contracts/sources/event.move +++ b/target_chains/sui/contracts/sources/event.move @@ -1,5 +1,5 @@ module pyth::event { - use iota::event::{Self}; + use sui::event::{Self}; use pyth::price_feed::{PriceFeed}; friend pyth::pyth; diff --git a/target_chains/sui/contracts/sources/governance/contract_upgrade.move b/target_chains/sui/contracts/sources/governance/contract_upgrade.move index 5f1918dff1..cc5aae0820 100644 --- a/target_chains/sui/contracts/sources/governance/contract_upgrade.move +++ b/target_chains/sui/contracts/sources/governance/contract_upgrade.move @@ -8,9 +8,9 @@ /// 3. Upgrade. /// 4. Commit upgrade. module pyth::contract_upgrade { - use iota::event::{Self}; - use iota::object::{ID}; - use iota::package::{UpgradeReceipt, UpgradeTicket}; + use sui::event::{Self}; + use sui::object::{ID}; + use sui::package::{UpgradeReceipt, UpgradeTicket}; use wormhole::bytes32::{Self, Bytes32}; use wormhole::cursor::{Self}; @@ -38,9 +38,9 @@ module pyth::contract_upgrade { } /// Redeem governance VAA to issue an `UpgradeTicket` for the upgrade given - /// a contract upgrade VAA. This governance message is only relevant for Iota + /// a contract upgrade VAA. This governance message is only relevant for Sui /// because a contract upgrade is only relevant to one particular network - /// (in this case Iota), whose build digest is encoded in this message. + /// (in this case Sui), whose build digest is encoded in this message. public fun authorize_upgrade( pyth_state: &mut State, receipt: WormholeVAAVerificationReceipt, @@ -86,7 +86,7 @@ module pyth::contract_upgrade { /// Finalize the upgrade that ran to produce the given `receipt`. This /// method invokes `state::commit_upgrade` which interacts with - /// `iota::package`. + /// `sui::package`. public fun commit_upgrade( self: &mut State, receipt: UpgradeReceipt, diff --git a/target_chains/sui/contracts/sources/governance/set_data_sources.move b/target_chains/sui/contracts/sources/governance/set_data_sources.move index e3fbe4287a..47148c30b5 100644 --- a/target_chains/sui/contracts/sources/governance/set_data_sources.move +++ b/target_chains/sui/contracts/sources/governance/set_data_sources.move @@ -49,8 +49,8 @@ module pyth::set_data_sources { #[test_only] module pyth::set_data_sources_tests { - use iota::test_scenario::{Self}; - use iota::coin::Self; + use sui::test_scenario::{Self}; + use sui::coin::Self; use wormhole::external_address::{Self}; use wormhole::bytes32::{Self}; diff --git a/target_chains/sui/contracts/sources/governance/set_stale_price_threshold.move b/target_chains/sui/contracts/sources/governance/set_stale_price_threshold.move index 69efd66312..c4a158dfd7 100644 --- a/target_chains/sui/contracts/sources/governance/set_stale_price_threshold.move +++ b/target_chains/sui/contracts/sources/governance/set_stale_price_threshold.move @@ -27,8 +27,8 @@ module pyth::set_stale_price_threshold { #[test_only] module pyth::set_stale_price_threshold_test { - use iota::test_scenario::{Self}; - use iota::coin::Self; + use sui::test_scenario::{Self}; + use sui::coin::Self; use pyth::pyth_tests::{Self, setup_test, take_wormhole_and_pyth_states}; use pyth::state::Self; diff --git a/target_chains/sui/contracts/sources/governance/set_update_fee.move b/target_chains/sui/contracts/sources/governance/set_update_fee.move index c5c7fa07f7..a0c2c11a10 100644 --- a/target_chains/sui/contracts/sources/governance/set_update_fee.move +++ b/target_chains/sui/contracts/sources/governance/set_update_fee.move @@ -1,5 +1,5 @@ module pyth::set_update_fee { - use std::u64; + use sui::math::{Self}; use wormhole::cursor; @@ -34,14 +34,14 @@ module pyth::set_update_fee { } fun apply_exponent(mantissa: u64, exponent: u8): u64 { - mantissa * u64::pow(10, exponent) + mantissa * math::pow(10, exponent) } } #[test_only] module pyth::set_update_fee_tests { - use iota::test_scenario::{Self}; - use iota::coin::Self; + use sui::test_scenario::{Self}; + use sui::coin::Self; use pyth::pyth_tests::{Self, setup_test, take_wormhole_and_pyth_states}; use pyth::state::Self; diff --git a/target_chains/sui/contracts/sources/merkle_tree.move b/target_chains/sui/contracts/sources/merkle_tree.move index eb96cde668..54545c6651 100644 --- a/target_chains/sui/contracts/sources/merkle_tree.move +++ b/target_chains/sui/contracts/sources/merkle_tree.move @@ -2,7 +2,7 @@ // with a given depth, as well as proving that a leaf node belongs to the tree. module pyth::merkle_tree { use std::vector::{Self}; - use iota::hash::{keccak256}; + use sui::hash::{keccak256}; use wormhole::bytes20::{Self, Bytes20, data}; use wormhole::cursor::Cursor; use pyth::deserialize::{Self}; @@ -89,9 +89,9 @@ module pyth::merkle_tree { false } - // The Iota Move stdlb insert function shifts v[i] and subsequent elements to the right. + // The Sui Move stdlb insert function shifts v[i] and subsequent elements to the right. // We don't want this behavior, so we define our own set_element function that instead replaces the ith element. - // Reference: https://github.com/MystenLabs/iota/blob/main/crates/iota-framework/packages/move-stdlib/sources/vector.move + // Reference: https://github.com/MystenLabs/sui/blob/main/crates/sui-framework/packages/move-stdlib/sources/vector.move fun set_element(a: &mut vector, value: T, index: u64){ vector::push_back(a, value); // push value to end vector::swap_remove(a, index); // swap value to correct position and pop last value diff --git a/target_chains/sui/contracts/sources/migrate.move b/target_chains/sui/contracts/sources/migrate.move index 49d53017b3..394691e6cd 100644 --- a/target_chains/sui/contracts/sources/migrate.move +++ b/target_chains/sui/contracts/sources/migrate.move @@ -11,7 +11,7 @@ /// any of Pyth's methods by enforcing the current build version as /// their required minimum version. module pyth::migrate { - use iota::object::{ID}; + use sui::object::{ID}; use pyth::state::{Self, State}; use pyth::contract_upgrade::{Self}; @@ -67,7 +67,7 @@ module pyth::migrate { // Finally emit an event reflecting a successful migrate. let package = state::current_package(&latest_only, pyth_state); - iota::event::emit(MigrateComplete { package }); + sui::event::emit(MigrateComplete { package }); } #[test_only] diff --git a/target_chains/sui/contracts/sources/price_info.move b/target_chains/sui/contracts/sources/price_info.move index 14b8acb5ee..8f5cea1346 100644 --- a/target_chains/sui/contracts/sources/price_info.move +++ b/target_chains/sui/contracts/sources/price_info.move @@ -1,10 +1,10 @@ module pyth::price_info { - use iota::object::{Self, UID, ID}; - use iota::tx_context::{TxContext}; - use iota::dynamic_object_field::{Self}; - use iota::table::{Self}; - use iota::coin::{Self, Coin}; - use iota::iota::IOTA; + use sui::object::{Self, UID, ID}; + use sui::tx_context::{TxContext}; + use sui::dynamic_object_field::{Self}; + use sui::table::{Self}; + use sui::coin::{Self, Coin}; + use sui::sui::SUI; use pyth::price_feed::{Self, PriceFeed}; use pyth::price_identifier::{PriceIdentifier}; @@ -18,7 +18,7 @@ module pyth::price_info { friend pyth::pyth; friend pyth::state; - /// Iota object version of PriceInfo. + /// Sui object version of PriceInfo. /// Has a key ability, is unique for each price identifier, and lives in global store. struct PriceInfoObject has key, store { id: UID, @@ -33,7 +33,7 @@ module pyth::price_info { } /// Creates a table which maps a PriceIdentifier to the - /// UID (in bytes) of the corresponding Iota PriceInfoObject. + /// UID (in bytes) of the corresponding Sui PriceInfoObject. public(friend) fun new_price_info_registry(parent_id: &mut UID, ctx: &mut TxContext) { assert!( !dynamic_object_field::exists_(parent_id, KEY), @@ -95,19 +95,19 @@ module pyth::price_info { } public fun get_balance(price_info_object: &PriceInfoObject): u64 { - if (!dynamic_object_field::exists_with_type, Coin>(&price_info_object.id, FEE_STORAGE_KEY)) { + if (!dynamic_object_field::exists_with_type, Coin>(&price_info_object.id, FEE_STORAGE_KEY)) { return 0 }; - let fee = dynamic_object_field::borrow, Coin>(&price_info_object.id, FEE_STORAGE_KEY); + let fee = dynamic_object_field::borrow, Coin>(&price_info_object.id, FEE_STORAGE_KEY); coin::value(fee) } - public fun deposit_fee_coins(price_info_object: &mut PriceInfoObject, fee_coins: Coin) { - if (!dynamic_object_field::exists_with_type, Coin>(&price_info_object.id, FEE_STORAGE_KEY)) { + public fun deposit_fee_coins(price_info_object: &mut PriceInfoObject, fee_coins: Coin) { + if (!dynamic_object_field::exists_with_type, Coin>(&price_info_object.id, FEE_STORAGE_KEY)) { dynamic_object_field::add(&mut price_info_object.id, FEE_STORAGE_KEY, fee_coins); } else { - let current_fee = dynamic_object_field::borrow_mut, Coin>( + let current_fee = dynamic_object_field::borrow_mut, Coin>( &mut price_info_object.id, FEE_STORAGE_KEY ); @@ -139,8 +139,8 @@ module pyth::price_info { #[test] public fun test_get_price_info_object_id_from_price_identifier(){ - use iota::object::{Self}; - use iota::test_scenario::{Self, ctx}; + use sui::object::{Self}; + use sui::test_scenario::{Self, ctx}; use pyth::price_identifier::{Self}; let scenario = test_scenario::begin(@pyth); let uid = object::new(ctx(&mut scenario)); diff --git a/target_chains/sui/contracts/sources/pyth.move b/target_chains/sui/contracts/sources/pyth.move index 710a94bb99..7d7ce52d4f 100644 --- a/target_chains/sui/contracts/sources/pyth.move +++ b/target_chains/sui/contracts/sources/pyth.move @@ -1,11 +1,11 @@ module pyth::pyth { use std::vector; - use iota::tx_context::{TxContext}; - use iota::coin::{Self, Coin}; - use iota::iota::{IOTA}; - use iota::transfer::{Self}; - use iota::clock::{Self, Clock}; - use iota::package::{UpgradeCap}; + use sui::tx_context::{TxContext}; + use sui::coin::{Self, Coin}; + use sui::sui::{SUI}; + use sui::transfer::{Self}; + use sui::clock::{Self, Clock}; + use sui::package::{UpgradeCap}; use pyth::event::{Self as pyth_event}; use pyth::data_source::{Self, DataSource}; @@ -166,7 +166,7 @@ module pyth::pyth { while (!vector::is_empty(&price_infos)){ let cur_price_info = vector::pop_back(&mut price_infos); - // Only create new Iota PriceInfoObject if not already + // Only create new Sui PriceInfoObject if not already // registered with the Pyth State object. if (!state::price_feed_object_exists( pyth_state, @@ -175,7 +175,7 @@ module pyth::pyth { ) ) ){ - // Create and share newly created Iota PriceInfoObject containing a price feed, + // Create and share newly created Sui PriceInfoObject containing a price feed, // and then register a copy of its ID with State. let new_price_info_object = price_info::new_price_info_object(cur_price_info, ctx); let price_identifier = price_info::get_price_identifier(&cur_price_info); @@ -263,12 +263,12 @@ module pyth::pyth { pyth_state: &PythState, price_updates: HotPotatoVector, price_info_object: &mut PriceInfoObject, - fee: Coin, + fee: Coin, clock: &Clock ): HotPotatoVector { let latest_only = state::assert_latest_only(pyth_state); - // On Iota, users get to choose which price feeds to update. They specify a single price feed to + // On Sui, users get to choose which price feeds to update. They specify a single price feed to // update at a time. We therefore charge the base fee for each such individual update. // This is a departure from Eth, where users don't get to necessarily choose. assert!(state::get_base_update_fee(pyth_state) <= coin::value(&fee), E_INSUFFICIENT_FEE); @@ -359,7 +359,7 @@ module pyth::pyth { /// get_price() is likely to abort unless you call update_price_feeds() to update the cached price /// beforehand, as the cached prices may be older than the stale price threshold. /// - /// The price_info_object is a Iota object with the key ability that uniquely + /// The price_info_object is a Sui object with the key ability that uniquely /// contains a price feed for a given price_identifier. /// public fun get_price(state: &PythState, price_info_object: &PriceInfoObject, clock: &Clock): Price { @@ -419,12 +419,12 @@ module pyth::pyth { module pyth::pyth_tests{ use std::vector::{Self}; - use iota::iota::IOTA; - use iota::coin::{Self, Coin}; - use iota::test_scenario::{Self, Scenario, ctx, take_shared, return_shared}; - use iota::package::Self; - use iota::object::{Self, ID}; - use iota::clock::{Self, Clock}; + use sui::sui::SUI; + use sui::coin::{Self, Coin}; + use sui::test_scenario::{Self, Scenario, ctx, take_shared, return_shared}; + use sui::package::Self; + use sui::object::{Self, ID}; + use sui::clock::{Self, Clock}; use pyth::state::{State as PythState}; use pyth::setup::{Self}; @@ -501,8 +501,8 @@ module pyth::pyth_tests{ #[test_only] /// Init Wormhole core bridge state. /// Init Pyth state. - /// Set initial Iota clock time. - /// Mint some IOTA fee coins. + /// Set initial Sui clock time. + /// Mint some SUI fee coins. public fun setup_test( stale_price_threshold: u64, governance_emitter_chain_id: u64, @@ -511,7 +511,7 @@ module pyth::pyth_tests{ initial_guardians: vector>, base_update_fee: u64, to_mint: u64 - ): (Scenario, Coin, Clock) { + ): (Scenario, Coin, Clock) { let scenario = test_scenario::begin(DEPLOYER); @@ -576,7 +576,7 @@ module pyth::pyth_tests{ ctx(&mut scenario) ); - let coins = coin::mint_for_testing(to_mint, ctx(&mut scenario)); + let coins = coin::mint_for_testing(to_mint, ctx(&mut scenario)); let clock = clock::create_for_testing(ctx(&mut scenario)); (scenario, coins, clock) } @@ -673,7 +673,7 @@ module pyth::pyth_tests{ assert!(pyth::get_total_update_fee(&pyth_state, vector::length>(&multiple_vaas)) == 5*DEFAULT_BASE_UPDATE_FEE, 1); return_shared(pyth_state); - coin::burn_for_testing(test_coins); + coin::burn_for_testing(test_coins); clock::destroy_for_testing(_clock); test_scenario::end(scenario); } @@ -699,7 +699,7 @@ module pyth::pyth_tests{ ); cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); - coin::burn_for_testing(test_coins); + coin::burn_for_testing(test_coins); test_scenario::end(scenario); } @@ -730,7 +730,7 @@ module pyth::pyth_tests{ ); cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); - coin::burn_for_testing(test_coins); + coin::burn_for_testing(test_coins); test_scenario::end(scenario); } @@ -779,7 +779,7 @@ module pyth::pyth_tests{ let price_info_object_3 = take_shared(&scenario); let price_info_object_4 = take_shared(&scenario); - // Create vector of price info objects (Iota objects with key ability and living in global store), + // Create vector of price info objects (Sui objects with key ability and living in global store), // which contain the price feeds we want to update. Note that these can be passed into // update_price_feeds in any order! //let price_info_object_vec = vector[price_info_object_1, price_info_object_2, price_info_object_3, price_info_object_4]; @@ -930,7 +930,7 @@ module pyth::pyth_tests{ // clean up test scenario test_scenario::next_tx(&mut scenario, DEPLOYER); - coin::burn_for_testing(coins); + coin::burn_for_testing(coins); cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); test_scenario::end(scenario); @@ -963,7 +963,7 @@ module pyth::pyth_tests{ // clean up test scenario test_scenario::next_tx(&mut scenario, DEPLOYER); - coin::burn_for_testing(coins); + coin::burn_for_testing(coins); cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); test_scenario::end(scenario); @@ -996,7 +996,7 @@ module pyth::pyth_tests{ // clean up test scenario test_scenario::next_tx(&mut scenario, DEPLOYER); - coin::burn_for_testing(coins); + coin::burn_for_testing(coins); cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); test_scenario::end(scenario); @@ -1029,7 +1029,7 @@ module pyth::pyth_tests{ // clean up test scenario test_scenario::next_tx(&mut scenario, DEPLOYER); - coin::burn_for_testing(coins); + coin::burn_for_testing(coins); cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); test_scenario::end(scenario); @@ -1072,7 +1072,7 @@ module pyth::pyth_tests{ // clean up test scenario test_scenario::next_tx(&mut scenario, DEPLOYER); - coin::burn_for_testing(coins); + coin::burn_for_testing(coins); cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); test_scenario::end(scenario); @@ -1110,7 +1110,7 @@ module pyth::pyth_tests{ #[test] fun test_create_and_update_multiple_price_feeds_with_accumulator_success() { - use iota::coin::Self; + use sui::coin::Self; let (scenario, coins, clock) = setup_test(500, 23, ACCUMULATOR_TESTS_EMITTER_ADDRESS, ACCUMULATOR_TESTS_DATA_SOURCE(), ACCUMULATOR_TESTS_INITIAL_GUARDIANS, DEFAULT_BASE_UPDATE_FEE, DEFAULT_COIN_TO_MINT); @@ -1165,7 +1165,7 @@ module pyth::pyth_tests{ return_shared(price_info_object); idx = idx + 1; }; - coin::burn_for_testing(coins); + coin::burn_for_testing(coins); // clean up test scenario test_scenario::next_tx(&mut scenario, DEPLOYER); @@ -1211,7 +1211,7 @@ module pyth::pyth_tests{ let price_info_object_3 = take_shared(&scenario); let price_info_object_4 = take_shared(&scenario); - // Create vector of price info objects (Iota objects with key ability and living in global store), + // Create vector of price info objects (Sui objects with key ability and living in global store), // which contain the price feeds we want to update. Note that these can be passed into // update_price_feeds in any order! //let price_info_object_vec = vector[price_info_object_1, price_info_object_2, price_info_object_3, price_info_object_4]; @@ -1300,7 +1300,7 @@ module pyth::pyth_tests{ return_shared(price_info_object_2); return_shared(price_info_object_3); return_shared(price_info_object_4); - coin::burn_for_testing(test_coins); + coin::burn_for_testing(test_coins); cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); test_scenario::end(scenario); @@ -1395,7 +1395,7 @@ module pyth::pyth_tests{ return_shared(price_info_object_3); return_shared(price_info_object_4); - coin::burn_for_testing(test_coins); + coin::burn_for_testing(test_coins); cleanup_worm_state_pyth_state_and_clock(worm_state, pyth_state, clock); test_scenario::end(scenario); } @@ -1403,8 +1403,8 @@ module pyth::pyth_tests{ // pyth accumulator tests (included in this file instead of pyth_accumulator.move to avoid dependency cycle - as we need pyth_tests::setup_test) #[test] fun test_parse_and_verify_accumulator_updates(){ - use iota::test_scenario::{Self, take_shared, return_shared}; - use iota::transfer::{Self}; + use sui::test_scenario::{Self, take_shared, return_shared}; + use sui::transfer::{Self}; let (scenario, coins, clock) = setup_test(500, 23, ACCUMULATOR_TESTS_EMITTER_ADDRESS, vector[], ACCUMULATOR_TESTS_INITIAL_GUARDIANS, 50, 0); let worm_state = take_shared(&scenario); @@ -1434,8 +1434,8 @@ module pyth::pyth_tests{ #[test] fun test_parse_and_verify_accumulator_updates_with_extra_bytes_at_end_of_message(){ - use iota::test_scenario::{Self, take_shared, return_shared}; - use iota::transfer::{Self}; + use sui::test_scenario::{Self, take_shared, return_shared}; + use sui::transfer::{Self}; let (scenario, coins, clock) = setup_test(500, 23, ACCUMULATOR_TESTS_EMITTER_ADDRESS, vector[], ACCUMULATOR_TESTS_INITIAL_GUARDIANS, 50, 0); let worm_state = take_shared(&scenario); diff --git a/target_chains/sui/contracts/sources/pyth_accumulator.move b/target_chains/sui/contracts/sources/pyth_accumulator.move index e00da563f0..46000b3609 100644 --- a/target_chains/sui/contracts/sources/pyth_accumulator.move +++ b/target_chains/sui/contracts/sources/pyth_accumulator.move @@ -1,6 +1,6 @@ module pyth::accumulator { use std::vector::{Self}; - use iota::clock::{Clock, Self}; + use sui::clock::{Clock, Self}; use wormhole::bytes20::{Self, Bytes20}; use wormhole::cursor::{Self, Cursor}; use pyth::deserialize::{Self}; diff --git a/target_chains/sui/contracts/sources/set.move b/target_chains/sui/contracts/sources/set.move index f6d76186be..b0f53549c8 100644 --- a/target_chains/sui/contracts/sources/set.move +++ b/target_chains/sui/contracts/sources/set.move @@ -1,7 +1,7 @@ /// A set data structure. module pyth::set { - use iota::table::{Self, Table}; - use iota::tx_context::{TxContext}; + use sui::table::{Self, Table}; + use sui::tx_context::{TxContext}; use std::vector; /// Empty struct. Used as the value type in mappings to encode a set diff --git a/target_chains/sui/contracts/sources/setup.move b/target_chains/sui/contracts/sources/setup.move index 04eaba1bfe..b92609bed8 100644 --- a/target_chains/sui/contracts/sources/setup.move +++ b/target_chains/sui/contracts/sources/setup.move @@ -1,8 +1,8 @@ module pyth::setup { - use iota::object::{Self, UID}; - use iota::package::{Self, UpgradeCap}; - use iota::transfer::{Self}; - use iota::tx_context::{Self, TxContext}; + use sui::object::{Self, UID}; + use sui::package::{Self, UpgradeCap}; + use sui::transfer::{Self}; + use sui::tx_context::{Self, TxContext}; use pyth::state::{Self}; use pyth::data_source::{DataSource}; @@ -34,7 +34,7 @@ module pyth::setup { // This will be created and sent to the transaction sender // automatically when the contract is published. transfer::public_transfer( - iota::package::test_publish(object::id_from_address(@pyth), ctx), + sui::package::test_publish(object::id_from_address(@pyth), ctx), tx_context::sender(ctx) ); } diff --git a/target_chains/sui/contracts/sources/state.move b/target_chains/sui/contracts/sources/state.move index 3dcf6e62b5..9381e6457f 100644 --- a/target_chains/sui/contracts/sources/state.move +++ b/target_chains/sui/contracts/sources/state.move @@ -1,8 +1,8 @@ module pyth::state { use std::vector; - use iota::object::{Self, UID, ID}; - use iota::tx_context::{Self, TxContext}; - use iota::package::{UpgradeCap, UpgradeTicket, UpgradeReceipt}; + use sui::object::{Self, UID, ID}; + use sui::tx_context::{Self, TxContext}; + use sui::package::{UpgradeCap, UpgradeTicket, UpgradeReceipt}; use pyth::data_source::{Self, DataSource}; use pyth::price_info::{Self}; @@ -280,7 +280,7 @@ module pyth::state { /// Issue an `UpgradeTicket` for the upgrade. /// - /// NOTE: The Iota VM performs a check that this method is executed from the + /// NOTE: The Sui VM performs a check that this method is executed from the /// latest published package. If someone were to try to execute this using /// a stale build, the transaction will revert with `PackageUpgradeError`, /// specifically `PackageIDDoesNotMatch`. @@ -294,7 +294,7 @@ module pyth::state { /// Finalize the upgrade that ran to produce the given `receipt`. /// - /// NOTE: The Iota VM performs a check that this method is executed from the + /// NOTE: The Sui VM performs a check that this method is executed from the /// latest published package. If someone were to try to execute this using /// a stale build, the transaction will revert with `PackageUpgradeError`, /// specifically `PackageIDDoesNotMatch`. @@ -362,7 +362,7 @@ module pyth::state { // Add back in old dynamic field(s)... // Add dummy hash since this is the first time the package is published. - iota::dynamic_field::add(&mut self.id, CurrentDigest {}, bytes32::from_bytes(b"new build")); + sui::dynamic_field::add(&mut self.id, CurrentDigest {}, bytes32::from_bytes(b"new build")); } #[test_only]