From e8487c62de8a4d7e8024ffcaeb1d8c90375a0709 Mon Sep 17 00:00:00 2001 From: Erin Shaben Date: Thu, 4 Jul 2024 09:29:36 -0400 Subject: [PATCH] Add XCM SDK docs (#248) --- .github/pull-request-template.md | 2 +- .gitignore | 3 + mkdocs/README.md | 39 + mkdocs/docs/.pages | 5 + mkdocs/docs/.snippets/text/endpoint-setup.md | 1 + .../.snippets/text/third-party-content.md | 3 + mkdocs/docs/contribute.md | 370 +++++ mkdocs/docs/example-usage.md | 892 +++++++++++ mkdocs/docs/index.md | 8 + mkdocs/docs/reference/.pages | 3 + mkdocs/docs/reference/interfaces.md | 839 ++++++++++ mkdocs/docs/reference/methods.md | 1365 +++++++++++++++++ .../material-overrides/assets/images/code.svg | 56 + .../assets/images/code.webp | Bin 0 -> 3400 bytes .../assets/images/contribute.svg | 56 + .../assets/images/contribute.webp | Bin 0 -> 1850 bytes .../assets/images/learn.svg | 52 + .../assets/images/learn.webp | Bin 0 -> 2176 bytes .../assets/images/logo-dark.webp | Bin 0 -> 8964 bytes .../assets/images/logo.webp | Bin 0 -> 8756 bytes .../images/moonbeam-foundation-dark.webp | Bin 0 -> 93794 bytes .../images/moonbeam-foundation-light.webp | Bin 0 -> 93790 bytes .../assets/stylesheets/custom.css | 394 +++++ .../fonts/BananaGrotesk-Regular.otf | Bin 0 -> 42268 bytes .../assets/stylesheets/home.css | 136 ++ mkdocs/material-overrides/home.html | 49 + mkdocs/material-overrides/main.html | 11 + .../material-overrides/partials/footer.html | 28 + .../material-overrides/partials/header.html | 64 + mkdocs/material-overrides/partials/logo.html | 10 + mkdocs/material-overrides/tutorial.html | 7 + mkdocs/mkdocs.yml | 72 + mkdocs/requirements.txt | 6 + packages/sdk/README.md | 12 +- 34 files changed, 4471 insertions(+), 12 deletions(-) create mode 100644 mkdocs/README.md create mode 100644 mkdocs/docs/.pages create mode 100644 mkdocs/docs/.snippets/text/endpoint-setup.md create mode 100644 mkdocs/docs/.snippets/text/third-party-content.md create mode 100644 mkdocs/docs/contribute.md create mode 100644 mkdocs/docs/example-usage.md create mode 100644 mkdocs/docs/index.md create mode 100644 mkdocs/docs/reference/.pages create mode 100644 mkdocs/docs/reference/interfaces.md create mode 100644 mkdocs/docs/reference/methods.md create mode 100644 mkdocs/material-overrides/assets/images/code.svg create mode 100644 mkdocs/material-overrides/assets/images/code.webp create mode 100644 mkdocs/material-overrides/assets/images/contribute.svg create mode 100644 mkdocs/material-overrides/assets/images/contribute.webp create mode 100644 mkdocs/material-overrides/assets/images/learn.svg create mode 100644 mkdocs/material-overrides/assets/images/learn.webp create mode 100644 mkdocs/material-overrides/assets/images/logo-dark.webp create mode 100644 mkdocs/material-overrides/assets/images/logo.webp create mode 100644 mkdocs/material-overrides/assets/images/moonbeam-foundation-dark.webp create mode 100644 mkdocs/material-overrides/assets/images/moonbeam-foundation-light.webp create mode 100644 mkdocs/material-overrides/assets/stylesheets/custom.css create mode 100644 mkdocs/material-overrides/assets/stylesheets/fonts/BananaGrotesk-Regular.otf create mode 100644 mkdocs/material-overrides/assets/stylesheets/home.css create mode 100644 mkdocs/material-overrides/home.html create mode 100644 mkdocs/material-overrides/main.html create mode 100644 mkdocs/material-overrides/partials/footer.html create mode 100644 mkdocs/material-overrides/partials/header.html create mode 100644 mkdocs/material-overrides/partials/logo.html create mode 100644 mkdocs/material-overrides/tutorial.html create mode 100644 mkdocs/mkdocs.yml create mode 100644 mkdocs/requirements.txt diff --git a/.github/pull-request-template.md b/.github/pull-request-template.md index deb59ab4..a6c07ace 100644 --- a/.github/pull-request-template.md +++ b/.github/pull-request-template.md @@ -4,7 +4,7 @@ Please explain the changes this PR addresses here. ### Checklist -- [ ] If this requires a documentation change, I have created a PR in [moonbeam-docs](https://github.com/moonbeam-foundation/moonbeam-docs) repository. +- [ ] If this requires a documentation change, I have created a PR that updates the `mkdocs/docs` directory - [ ] If this requires it, I have updated the Readme - [ ] If necessary, I have updated the examples - [ ] I have verified if I need to create/update unit tests diff --git a/.gitignore b/.gitignore index 7137c53b..5750d4b3 100644 --- a/.gitignore +++ b/.gitignore @@ -114,3 +114,6 @@ dist # IntelliJ Idea .idea + +# Docs - Site directory +mkdocs/site \ No newline at end of file diff --git a/mkdocs/README.md b/mkdocs/README.md new file mode 100644 index 00000000..d6dd9c8c --- /dev/null +++ b/mkdocs/README.md @@ -0,0 +1,39 @@ +# Documentation for the XCM SDK + +## Publishing New Versions + +To add the very first version, you’ll need to push the latest changes to the `main` branch and then in your terminal run: + +```bash +mike deploy --push INSERT_NEW_VERSION latest +``` + +Where the version should be formatted like `v0`, as we only need to worry about maintaining documentation for major version changes. + +For additional versions, you'll need to run: + +```bash +mike deploy --push --update-aliases INSERT_NEW_VERSION latest +``` + +## Publishing Changes to a Specific Version + +To make minor updates to the current version or an older version, you’ll need to make the changes to the `main` branch and then in your terminal run: + +```bash +mike deploy --push INSERT_VERSION +``` + +If using the latest version, you can cross-reference the live website, or the `gh-pages` branch to get the version that needs to be provided to the above command. + +Please note that modifying a previous version is possible, but should not be done unless necessary. It will require you to roll back changes to that version. For example, if the current version is v2 and you make a change and want to apply it to v0, the rest of the pages must be on v0, otherwise, the v2 changes will be applied to v0. + +## Setting a Default Version + +After setting the `latest` alias as the default version, and when publishing a new version, always update the alias to point to the latest version by running: + +```bash +mike set-default --push latest +``` + +When publishing a new version, this will create a redirect in the root of the documentation to the version associated with the alias. So, `https://moonbeam-foundation.github.io/xcm-sdk/` will redirect to `https://moonbeam-foundation.github.io/xcm-sdk/latest/`. diff --git a/mkdocs/docs/.pages b/mkdocs/docs/.pages new file mode 100644 index 00000000..2ad76777 --- /dev/null +++ b/mkdocs/docs/.pages @@ -0,0 +1,5 @@ +nav: + - 'index.md' + - 'SDK Reference': 'reference' + - 'Using the XCM SDK': 'example-usage.md' + - 'Contribute': 'contribute.md' diff --git a/mkdocs/docs/.snippets/text/endpoint-setup.md b/mkdocs/docs/.snippets/text/endpoint-setup.md new file mode 100644 index 00000000..6a9ecd95 --- /dev/null +++ b/mkdocs/docs/.snippets/text/endpoint-setup.md @@ -0,0 +1 @@ +To configure your project for Moonbeam or Moonriver, you will need to have your own endpoint and API key, which you can get from one of the supported [Endpoint Providers](https://docs.moonbeam.network/builders/get-started/endpoints){target=\_blank}. diff --git a/mkdocs/docs/.snippets/text/third-party-content.md b/mkdocs/docs/.snippets/text/third-party-content.md new file mode 100644 index 00000000..182579fd --- /dev/null +++ b/mkdocs/docs/.snippets/text/third-party-content.md @@ -0,0 +1,3 @@ +
+The information presented herein has been provided by third parties and is made available solely for general information purposes. Moonbeam does not endorse any project listed and described on the Moonbeam Doc Website (https://docs.moonbeam.network/). Moonbeam Foundation does not warrant the accuracy, completeness or usefulness of this information. Any reliance you place on such information is strictly at your own risk. Moonbeam Foundation disclaims all liability and responsibility arising from any reliance placed on this information by you or by anyone who may be informed of any of its contents. All statements and/or opinions expressed in these materials are solely the responsibility of the person or entity providing those materials and do not necessarily represent the opinion of Moonbeam Foundation. The information should not be construed as professional or financial advice of any kind. Advice from a suitably qualified professional should always be sought in relation to any particular matter or circumstance. The information herein may link to or integrate with other websites operated or content provided by third parties, and such other websites may link to this website. Moonbeam Foundation has no control over any such other websites or their content and will have no liability arising out of or related to such websites or their content. The existence of any such link does not constitute an endorsement of such websites, the content of the websites, or the operators of the websites. These links are being provided to you only as a convenience and you release and hold Moonbeam Foundation harmless from any and all liability arising from your use of this information or the information provided by any third-party website or service. +
diff --git a/mkdocs/docs/contribute.md b/mkdocs/docs/contribute.md new file mode 100644 index 00000000..d52c00ea --- /dev/null +++ b/mkdocs/docs/contribute.md @@ -0,0 +1,370 @@ +--- +title: Add Assets or Chains to the XCM SDK +description: Learn how to add an asset or chain within the Polkadot or Kusama ecosystems to the Moonbeam XCM SDK. +template: tutorial.html +--- + +# Contribute to the XCM SDK + +## Get Started + +To contribute to the XCM SDK, you'll first need to clone the GitHub repository: + +```bash +git clone git@github.com:moonbeam-foundation/xcm-sdk.git +``` + +Then, install dependencies: + +```bash +npm install +``` + +## Add an Asset + +The first step in adding support for a new asset is to define the asset in the [assets configuration file](https://github.com/moonbeam-foundation/xcm-sdk/blob/main/packages/config/src/assets.ts){target=\_blank}. At this stage, assets are not bound to any chain, you are only creating a representation of the asset. + +Follow these steps: + +1. Open the `xcm-sdk/packages/config/src/assets.ts` file +2. Create a new variable for your asset. You'll need to create an [Asset Object](./reference/interfaces.md#the-asset-object), providing the `key` and `originSymbol` of the asset + + ```ts + export const INSERT_ASSET_NAME = new Asset({ + key: 'INSERT_KEY', + originSymbol: 'INSERT_ORIGIN_SYMBOL', + }); + ``` + + For example, this is the configuration used for USDT: + + ```ts + export const usdt = new Asset({ + key: 'usdt', + originSymbol: 'USDT', + }); + ``` + +3. Add your asset to the `assetsList` array at the end of the file + +!!! note + Assets are listed in alphabetical order. Please make sure you follow this order when adding new assets. + +## Add a Chain + +The next step to support an asset integration is to add chain information for the chains in which your asset can be sent to and from to the [chains configuration file](https://github.com/moonbeam-foundation/xcm-sdk/blob/main/packages/config/src/chains.ts){target=\_blank}. + +To add a chain, take the following steps: + +1. Open the `xcm-sdk/packages/config/src/chains.ts` file +2. Add your asset to the list of imported assets from the assets configuration file (`./assets.ts`) +3. Create a new variable for each chain if an entry doesn't already exist. You'll need to create a [Chain Object](./reference/interfaces.md#the-chain-object), providing metadata related to the chain + + === "Parachain" + + ```ts + new Parachain({ + assetsData: [], // Optional - In the next step, you'll add assets here + ecosystem: Ecosystem.INSERT_ECOSYSTEM_TYPE, // Optional + genesisHash: 'INSERT_GENESIS_HASH', + isTestChain: INSERT_BOOLEAN, // Optional + key: 'INSERT_KEY', + name: 'INSERT_NAME', + parachainId: INSERT_PARACHAIN_ID, + ss58Format: INSERT_SS58_FORMAT, + usesChainDecimals: INSERT_BOOLEAN, // Optional + ws: 'INSERT_WSS_ENDPOINT', + }) + ``` + + === "EVM Parachain" + + ```ts + new EvmParachain({ + assetsData: [], // Optional - In the next step, you'll add assets here + ecosystem: Ecosystem.INSERT_ECOSYSTEM_TYPE, // Optional + genesisHash: 'INSERT_GENESIS_HASH', + id: INSERT_EVM_CHAIN_ID, + isTestChain: INSERT_BOOLEAN, // Optional + key: 'INSERT_KEY', + name: 'INSERT_NAME', + nativeCurrency: { + decimals: INSERT_ASSET_DECIMALS, + name: 'INSERT_ASSET_NAME', + symbol: 'INSERT_ASSET_SYMBOL', + }, + parachainId: INSERT_PARACHAIN_ID, + rpc: 'INSERT_RPC_ENDPOINT', + ss58Format: INSERT_SS58_FORMAT, + usesChainDecimals: INSERT_BOOLEAN, // Optional + ws: 'INSERT_WSS_ENDPOINT', + }) + ``` + + For example, this is the configuration for the Polkadot Asset Hub: + + ```ts + export const polkadotAssetHub = new Parachain({ + assetsData: [ ... ], + ecosystem: Ecosystem.Polkadot, + genesisHash: + '0x68d56f15f85d3136970ec16946040bc1752654e906147f7e43e9d539d7c3de2f', + key: 'Polkadot-asset-hub', + name: 'Polkadot Asset Hub', + parachainId: 1000, + ss58Format: 42, + ws: 'wss://polkadot-asset-hub-rpc.polkadot.io', + }); + ``` + +4. Add the newly created chain to the `chainsList` array at the end of the file + +!!! note + Chains are listed in alphabetical order. Please make sure you follow this order when adding new chains. + +Now that you've added the chain, you can continue to the next section to add the assets that this chain supports. + +## Configure a Chain's Assets + +To designate a chain as a destination or source chain for an asset, you must specify the asset within the `assetsData` array of the chain's configuration. This array outlines the supported assets on the chain, and the asset information within it determines how the asset is identified or targeted on that specific chain. For example, when adding a chain's native asset, you'll need to define how the chain sees its own asset, and when adding the asset to a destination chain, you'll need to define how the destination chain sees the asset. + +To enable an asset to move between chains, follow these steps to configure the source and destination chains of an asset: + +1. In the `assetsData` array of the source chain, you'll need to create a [Chain Asset Data Object](./reference/interfaces.md#the-chain-assets-data-object) for the asset, specifying how the asset is seen on that chain + + ```ts + { + asset: INSERT_IMPORTED_ASSET, // The asset created in the previous section + balanceId: INSERT_CHAIN_ASSET_ID, // (Optional) The balance ID of the asset + decimals: INSERT_ASSET_DECIMALS // (Optional) The decimals of the asset + id: INSERT_CHAIN_ASSET_ID, // (Optional) Location of the asset on the chain. Different for every chain + metadata: INSERT_CHAIN_ASSET_ID // (Optional) The metadata of the asset + min: INSERT_MIN // (Optional) The minimum amount of the asset that is required to be left in the account + minId: INSERT_CHAIN_ASSET_ID // (Optional) The minimum ID of the asset + palletInstance: INSERT_PALLET_INSTANCE // (Optional) The pallet instance the asset belongs to + } + ``` + + For example, this is the configuration for USDT on the Polkadot Asset Hub: + + ```ts + export const polkadotAssetHub = new Parachain({ + assetsData: [ + { + asset: usdt, + id: 1984, // The asset ID for USDT + palletInstance: 50, // The index of the Assets pallet (where USDT lives) + }, + ], + ... + }); + ``` + +2. In the destination chain's `assetsData` array, create a [Chain Asset Data Object](./reference/interfaces.md#the-chain-assets-data-object) that defines the asset as seen on the destination chain. This will be different than the source chain's configurations, as every chain manages assets differently + + For example, to add support for USDT on Moonbeam, Moonbeam's chain configuration needs to include the configuration for USDT: + + ```ts + export const moonbeam = new EvmParachain({ + assetsData: [ + ... + { + asset: usdt, + id: '311091173110107856861649819128533077277', // The asset ID of USDT on Moonbeam + }, + ... + ] + ... + }); + ``` + +The integration isn't complete yet; you'll need to define the methods used for cross-chain transfers for any new chains added. This will be covered in the following section. + +## Configure a Chain's Extrinsics + +In this step, you have to create or update the configuration files of the chains between which you can transfer the asset. These files define the asset being transferred, the destination chain, information associated to fees, and builder functions. These builders define the pallets and methods necessary to achieve the specific goals of each type. They are as follows: + +- **Minimum Asset Builder** - builds a query to retrieve the minimum amount of an asset required to be left in an account +- **Balance Builder** - builds a query to retrieve the balance of an asset for a given account +- **Contract Builder** - builds the contract call for the cross-chain transfer. This is specific to EVM chains that use contracts to interact with Substrate pallets for cross-chain transfers, such as [Moonbeam's X-Tokens precompiled contract](https://docs.moonbeam.network/builders/interoperability/xcm/xc20/send-xc20s/xtokens-precompile/){target=\_blank} +- **Extrinsic Builder** - builds the extrinsic for the cross-chain transfer +- **Fee Builder** - builds the query to retrieve the fee for the execution of the cross-chain transfer + +You will need to know which pallet and method each chain is using for its XCM transactions and for fetching asset balances, and make sure that said pallets and methods are already available in the [xcm-builder package](https://github.com/moonbeam-foundation/xcm-sdk/tree/main/packages/builder){target=\_blank}. + +If they aren't available, feel free to open a PR or [submit an issue on GitHub](https://github.com/moonbeam-foundation/xcm-sdk/issues/new){target=\_blank}. + +Assuming that all of the required pallets and methods are already supported, you can create the configuration file for the source chain: + +1. In the `xcm-sdk/packages/config/src/configs/` directory, add a TypeScript file for the new chain +2. Use the following snippet as a starting point for adding the chain configuration: + + ```ts + import { INSERT_REQUIRED_BUILDERS } from '@moonbeam-network/xcm-builder'; + import { INSERT_REQUIRED_ASSETS } from '../assets'; + import { INSERT_SOURCE_CHAIN, INSERT_DESTINATION_CHAIN } from '../chains'; + import { AssetConfig } from '../types/AssetConfig'; + import { ChainConfig } from '../types/ChainConfig'; + + // The chain config name should be formatted as: 'chainName' + 'Config' + export const INSERT_CHAIN_CONFIG_NAME = new ChainConfig({ + assets: [], // In the next step, you'll add asset configs here + chain: INSERT_SOURCE_CHAIN, // The source chain + }); + ``` + +3. As seen in the above example, an `assets` array contains the chain's asset configurations. The asset configuration defines the asset being transferred, the destination chain, information associated with fees, and the builder functions. The builder functions must be used to build the queries or calls as if they were being executed from this chain. + + You'll need to create an Asset Config object for each asset, for example: + + ```ts + new AssetConfig({ + asset: INSERT_ASSET, + balance: INSERT_BALANCE_BUILDER, + contract: INSERT_CONTRACT_BUILDER, // Optional + destination: INSERT_DESTINATION_CHAIN, + destinationFee: { + amount: INSERT_FEE_BUILDER, + asset: INSERT_ASSET, + balance: INSERT_BALANCE_BUILDER, + }, + extrinsic: INSERT_EXTRINSIC_BUILDER, // Optional + fee: { + // Optional + asset: INSERT_ASSET, + balance: INSERT_BALANCE_BUILDER, + xcmDeliveryFeeAmount: INSERT_FEE_AMOUNT, // Optional + }, + min: INSERT_MIN_ASSET_BUILDER, // Optional + }); + ``` + +4. Add the newly created chain configurations to the `chainsConfigList` in the `xcm-sdk/blob/main/packages/config/src/configs/index.ts` file + +!!! note + Chain configurations are listed in alphabetical order. Please follow this order when adding new chain configurations. + +For example, to add support to transfer USDT from the Polkadot Asset Hub to Moonbeam, the Polkadot Asset Hub configuration file is as follows: + +```ts +import { + AssetMinBuilder, + BalanceBuilder, + ExtrinsicBuilder, + FeeBuilder, +} from '@moonbeam-network/xcm-builder'; +import { usdt } from '../assets'; +import { moonbeam, polkadotAssetHub } from '../chains'; +import { AssetConfig } from '../types/AssetConfig'; +import { ChainConfig } from '../types/ChainConfig'; + +const xcmDeliveryFeeAmount = 0.036; + +export const polkadotAssetHubConfig = new ChainConfig({ + assets: [ + ...new AssetConfig({ + asset: usdt, + balance: BalanceBuilder().substrate().assets().account(), + destination: moonbeam, + destinationFee: { + amount: FeeBuilder().assetManager().assetTypeUnitsPerSecond(), + asset: usdt, + balance: BalanceBuilder().substrate().assets().account(), + }, + extrinsic: ExtrinsicBuilder() + .polkadotXcm() + .limitedReserveTransferAssets() + .X2(), + fee: { + asset: dot, + balance: BalanceBuilder().substrate().system().account(), + xcmDeliveryFeeAmount, + }, + min: AssetMinBuilder().assets().asset(), + }), + ], + chain: polkadotAssetHub, +}); +``` + +You're almost there. With this configuration, you can send the asset one-way from the configured chain to the asset's specified destination chain. To send the asset back to the original source chain, you must update (or create) the specified destination chain's configurations. Considering the above example, the Moonbeam configuration file would need to be updated to transfer USDT from Moonbeam back to the Polkadot Asset Hub. + +You must take the same steps in the destination chain's configuration file. If a configuration file does not exist, you must create one. Otherwise, update the chain's configuration file to include the asset configuration, as step three outlines. + +For example, enabling USDT transfers from Moonbeam back to the Polkadot Asset Hub requires the following Moonbeam chain configuration: + +```ts +import { BalanceBuilder, ContractBuilder } from '@moonbeam-network/xcm-builder'; +import { + ... + usdt, +} from '../assets'; +import { + ... + polkadotAssetHub, +} from '../chains'; +import { AssetConfig } from '../types/AssetConfig'; +import { ChainConfig } from '../types/ChainConfig'; + +export const moonbeamConfig = new ChainConfig({ + assets: [ + ... + new AssetConfig({ + asset: usdt, + balance: BalanceBuilder().substrate().assets().account(), + contract: ContractBuilder().Xtokens().transfer(), + destination: polkadotAssetHub, + destinationFee: { + amount: 0.7, + asset: usdt, + balance: BalanceBuilder().substrate().assets().account(), + }, + fee: { + asset: glmr, + balance: BalanceBuilder().substrate().system().account(), + }, + }), + ], + chain: moonbeam, +}); +``` + +And that's it! You now know how to add new assets and chains and configure the chains that an asset can be sent to and from. To ensure that you've properly set everything up, read on to the next section. + +## Test New Configurations + +The SDK is configured to work for most parachains in the Polkadot ecosystem. However, any given chain might have a different or particular way of requesting a specific piece of information, for example, if it uses unconventional pallets or different methods for existing pallets. + +You can use the following queries to ensure that the new configurations have been properly set up. + +- `assetRegistry.assetMetadatas` - From here, we extract the `decimals` and the `minBalance` for + `aSEED`: + + ```js + { + name: aUSD SEED + symbol: aSEED + decimals: 12 + minimalBalance: 100,0 + } + ``` + +- `assets.metadata` - Here, we get the `decimals` for `DOT` + + ```js + { + deposit: 0; + name: xcDOT; + symbol: xcDOT; + decimals: 10; + isFrozen: false; + } + ``` + +- `balances.existentialDeposit` - This is the standard way of querying the existential deposit for most chains + + ```js + 100000000000; + ``` + +Most cases are considered already, but for newly integrated chains, this data might be queried by a different pallet or function. You can check if the pallet is supported in the [Polkadot Service file](https://github.com/moonbeam-foundation/xcm-sdk/blob/main/packages/sdk/src/polkadot/PolkadotService.ts). diff --git a/mkdocs/docs/example-usage.md b/mkdocs/docs/example-usage.md new file mode 100644 index 00000000..0aa16c5d --- /dev/null +++ b/mkdocs/docs/example-usage.md @@ -0,0 +1,892 @@ +--- +title: Using the XCM SDK v2 +description: Use the Moonbeam XCM SDK to easily transfer cross-chain assets between parachains or between a parachain and relay chain within the Polkadot/Kusama ecosystems. +template: tutorial.html +--- + +# Using the Moonbeam XCM SDK + +## Introduction {: #introduction } + +The Moonbeam XCM SDK enables developers to easily transfer assets between chains, either between parachains or between a parachain and the relay chain, within the Polkadot/Kusama ecosystem. With the SDK, you don't need to worry about determining the multilocation of the origin or destination assets or which extrinsics are used on which networks to send XCM transfers. + +The XCM SDK offers helper functions that provide a very simple interface for executing XCM transfers between chains in the Polkadot/Kusama ecosystem. In addition, the XCM config package allows any parachain project to [add their information](./contribute.md) in a standard way, so the XCM SDK can immediately support them. + +For an overview of the available methods and interfaces in the Moonbeam XCM SDK, please refer to the [Reference](./reference/interfaces.md){target=\_blank} page. + +This guide shows how to transfer DOT from Polkadot to Moonbeam. + +## Install the XCM SDK {: #install-the-xcm-sdk } + +To get started with the Moonbeam XCM SDK, you'll need first to install the SDK: + +```bash +npm install @moonbeam-network/xcm-sdk +``` + +You'll also need to install a few additional dependencies that you'll use to interact with the SDK in this guide. You'll need the Polkadot.js API to create a Polkadot signer: + +```bash +npm install @polkadot/api @polkadot/util-crypto +``` + +You'll also need an Ethereum signer if you're interacting with an Ethereum-compatible chain like Moonbeam. This guide will cover using Ethers.js and viem. You'll need to install whichever library you want to use: + +=== "Ethers.js" + + ```bash + npm install ethers@6 + ``` + +=== "viem" + + ```bash + npm install viem@2 + ``` + +## Create Signers {: #create-signers } + +When transferring assets between chains, you'll need signers in place to sign the transactions. If you're interacting with an Ethereum-compatible chain that uses standard Ethereum-style H160 addresses, such as Moonbeam, you'll need to have an Ethereum signer, which can be an [Ethers.js](https://docs.ethers.org/v5/){target=\_blank} signer or a [viem Wallet Client](https://viem.sh/docs/clients/wallet.html){target=\_blank}. To interact with the relay chain or other parachains, you'll need a [Polkadot](https://polkadot.js.org/docs/api/){target=\_blank} signer. + +You can pass, for example, a [browser extension wallet as a signer into Ethers](https://docs.ethers.org/v5/getting-started/#getting-started--connecting){target=\_blank} or [viem](https://viem.sh/docs/clients/wallet.html#json-rpc-accounts){target=\_blank}, such as MetaMask. Similarly, with Polkadot, you can [pass a compatible wallet to the signer using the `@polkadot/extension-dapp` library](https://polkadot.js.org/docs/extension/){target=\_blank}. + +To create an EVM signer and a Polkadot signer, you can refer to the following sections. + +!!! warning + **Never store your private key or mnemonic in a JavaScript or TypeScript file.** + +### Create an EVM Signer {: #create-a-evm-signer } + +To create an Ethers signer, you can use the following code snippet: + +```js +import { ethers } from 'ethers'; + +const privateKey = 'INSERT_PRIVATE_KEY'; +const provider = new ethers.WebSocketProvider('INSERT_WS_ENDPOINT', { + chainId: INSERT_CHAIN_ID, + name: 'INSERT_CHAIN_NAME', +}); +const evmSigner = new ethers.Wallet(privateKey, provider); +``` + +For Moonbeam specifically, you can use the following configurations: + +=== "Moonbeam" + + ```js + import { ethers } from 'ethers'; + + const privateKey = 'INSERT_PRIVATE_KEY'; + const provider = new ethers.WebSocketProvider( + '{{ networks.moonbeam.wss_url }}', + { + chainId: {{ networks.moonbeam.chain_id }}, + name: 'moonbeam', + } + ); + const evmSigner = new ethers.Wallet(privateKey, provider); + ``` + +=== "Moonriver" + + ```js + import { ethers } from 'ethers'; + + const privateKey = 'INSERT_PRIVATE_KEY'; + const provider = new ethers.WebSocketProvider( + '{{ networks.moonriver.wss_url }}', + { + chainId: {{ networks.moonriver.chain_id }}, + name: 'moonriver', + } + ); + const evmSigner = new ethers.Wallet(privateKey, provider); + ``` + +=== "Moonbase Alpha" + + ```js + import { ethers } from 'ethers'; + + const privateKey = 'INSERT_PRIVATE_KEY'; + const provider = new ethers.WebSocketProvider( + '{{ networks.moonbase.wss_url }}', + { + chainId: {{ networks.moonbase.chain_id }}, + name: 'moonbase', + } + ); + const evmSigner = new ethers.Wallet(privateKey, provider); + ``` + +Alternatively, you can create a viem Wallet Client to pass as an EVM signer: + +=== "Moonbeam" + + ```js + import { createWalletClient, http } from 'viem'; + import { privateKeyToAccount } from 'viem/accounts' + import { moonbeam } from 'viem/chains'; + + const privateKey = 'INSERT_PRIVATE_KEY'; + const account = privateKeyToAccount(privateKey); + + const evmSigner = createWalletClient({ + account, + chain: moonbeam, + transport: http(), + }); + ``` + +=== "Moonriver" + + ```js + import { createWalletClient, http } from 'viem'; + import { privateKeyToAccount } from 'viem/accounts' + import { moonriver } from 'viem/chains'; + + const privateKey = 'INSERT_PRIVATE_KEY'; + const account = privateKeyToAccount(privateKey); + + const evmSigner = createWalletClient({ + account, + chain: moonriver, + transport: http(), + }); + ``` + +=== "Moonbase Alpha" + + ```js + import { createWalletClient, http } from 'viem'; + import { privateKeyToAccount } from 'viem/accounts' + import { moonbaseAlpha } from 'viem/chains'; + + const privateKey = 'INSERT_PRIVATE_KEY'; + const account = privateKeyToAccount(privateKey); + + const evmSigner = createWalletClient({ + account, + chain: moonbaseAlpha, + transport: http(), + }); + ``` + +If you want to pass in a browser extension wallet to viem, you can use the following code: + +=== "Moonbeam" + + ```js + import { createWalletClient, custom } from 'viem'; + import { moonbeam } from 'viem/chains'; + + const evmSigner = createWalletClient({ + chain: moonbeam, + transport: custom(window.ethereum), + }); + ``` + +=== "Moonriver" + + ```js + import { createWalletClient, custom } from 'viem'; + import { moonriver } from 'viem/chains'; + + const evmSigner = createWalletClient({ + chain: moonriver, + transport: custom(window.ethereum), + }); + ``` + +=== "Moonbase Alpha" + + ```js + import { createWalletClient, custom } from 'viem'; + import { moonbaseAlpha } from 'viem/chains'; + + const evmSigner = createWalletClient({ + chain: moonbaseAlpha, + transport: custom(window.ethereum), + }); + ``` + +!!! note + --8<-- 'text/endpoint-setup.md' + +### Create a Polkadot Signer {: #create-a-polkadot-signer } + +In this example, you can use a [Polkadot.js Keyring](https://polkadot.js.org/docs/api/start/keyring/){target=\_blank} to sign transactions. Please note that this approach is not recommended for production applications. + +```js +import { Keyring } from '@polkadot/api'; +import { cryptoWaitReady } from '@polkadot/util-crypto'; + +const privateKey = 'INSERT_PRIVATE_KEY'; + +const createPolkadotSigner = async () => { + await cryptoWaitReady(); + const keyring = new Keyring({ + ss58Format: 'INSERT_SS58_FORMAT', + type: 'sr25519', + }); + const pair = keyring.createFromUri(privateKey); +}; + +createPolkadotSigner(); +``` + +!!! note + In the above `INSERT_PRIVATE_KEY` field, you can specify a seed phrase instead of a private key. + +## Get Asset and Chain Data {: #asset-chain-data } + +You can use any of the following code examples to retrieve information on the supported assets and the chains that support these assets. + +### Get List of Supported Assets {: #get-list-of-supported-assets } + +To get a list of all of the assets supported by the XCM SDK, you can instantiate the XCM SDK and call the [`assets`](./reference/methods.md#the-assets-method) function. + +```js +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const assets = sdkInstance.assets(); + +console.log('The supported assets are as follows:'); +assets.assets.forEach((asset) => { + console.log(`- ${asset.originSymbol}`); +}); +``` + +### Get List of Supported Assets by Ecosystem {: #get-supported-assets-by-ecosystem } + +To get a list of the supported assets for a particular [ecosystem](./reference/interfaces.md#the-ecosystem-type), you can pass in the ecosystem name: `polkadot`, `kusama`, or `alphanet-relay`. For example, the following snippet will get all of the Polkadot assets supported: + +```js +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const assets = sdkInstance.assets('polkadot'); + +console.log( + 'The supported assets within the Polkadot ecosystem are as follows:', +); +assets.assets.forEach((asset) => { + console.log(`- ${asset.originSymbol}`); +}); +``` + +### Get List of Supported Chains by Asset {: #get-list-of-supported-assets-by-chain } + +To get a list of the supported [source](./reference/methods.md#the-source-method) and [destination](./reference/methods.md#the-destination-method) chains for a given asset, you can use the following code snippet, which logs the supported chains by asset for all of the supported assets in the Polkadot ecosystem: + +```js +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const assets = sdkInstance.assets('polkadot'); + +assets.assets.forEach((asset) => { + const { sourceChains, source } = assets.asset(asset); + console.log(`You can send ${asset.originSymbol}...`); + if (sourceChains.length > 1) { + sourceChains.forEach((sourceChain) => { + const { destinationChains } = source(sourceChain); + if (destinationChains.length > 0) { + destinationChains.forEach((destination) => { + console.log(`- From ${source.name} to ${destination.name}`); + }); + } + }); + } +}); +``` + +## Build XCM Transfer Data {: #build-xcm-transfer-data } + +To transfer an asset from one chain to another, you'll need to first build the transfer data, which defines the asset to be transferred, the source chain and address, the destination chain and address, and the associated signer for the transaction. Building the transfer data is the first step; in the next section, you'll learn how to use it to actually transfer the asset. + +To get started, you'll use the [`Sdk`](./reference/methods.md#initialize-the-sdk) function, which will expose two methods for building the XCM transfer data: [`assets`](./reference/methods.md#the-assets-method) and [`getTransferData`](./reference/methods.md#the-get-transfer-data-method). + +```js +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +``` + +You can choose either method, as both will return the data necessary to initiate an asset transfer between the source and destination chains. Using `assets` will provide additional data along the way, including the list of supported assets and, once an asset is selected, the supported source and destination chains that can send and receive it. + +The process for using `assets` to build the transfer data is as follows: + +1. Call the `assets` function and optionally pass in the ecosystem that you want to retrieve a list of assets for or that the asset you want to transfer belongs to. The available ecosystems are: `polkadot`, `kusama`, and `alphanet-relay`. For example: + + ```js + const { assets, asset } = sdkInstance.assets('polkadot'); + ``` + + This will return a list of the supported assets and the [`asset`](./reference/methods.md#the-asset-method) function that can be used to define the asset to be transferred + +2. Call the `asset` function and pass in the key or asset object (which includes the key and the origin symbol) to define the asset to be transferred. For example: + + ```js + // Using the key + const { sourceChains, source } = asset('dot'); + ``` + + This will return a list of the supported source chains and the [`source`](./reference/methods.md#the-source-method) function, which is used to define the source chain to transfer the asset from + +3. Call the `source` function and pass in the key or the chain object (which includes the key, name, and chain type). For example: + + ```js + // Using the key + const { destinationChains, destination } = source('polkadot'); + ``` + + This will return a list of the supported destination chains where there is an open XCM channel from the source chain for the given asset and the [`destination`](./reference/methods.md#the-destination-method) function, which is used to define the destination chain to transfer the asset to + +4. Call the `destination` function and pass in the key or the chain object (which includes the key, name, and chain type). For example: + + ```js + // Using the key + const { accounts } = destination('moonbeam'); + ``` + + This will return the [`accounts`](./reference/methods.md#the-accounts-method) function, which is used to define the source and destination addresses and the associated signers for each address + +The asset and chain objects are managed within the `@moonbeam-network/xcm-config` package. You do not need to directly interact with this package as the SDK exposes this data, but there you can find the list of [assets](https://github.com/moonbeam-foundation/xcm-sdk/blob/main/packages/config/src/assets.ts){target=\_blank} and [chain data](https://github.com/moonbeam-foundation/xcm-sdk/blob/main/packages/config/src/chains.ts){target=\_blank}. + +An example of the steps described above to build the transfer data to transfer DOT from the Polkadot relay chain to Moonbeam is as follows: + +```js +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); + +const fromPolkadot = async () => { + const { assets, asset } = sdkInstance.assets(); + console.log( + `The supported assets are: ${assets.map((asset) => asset.originSymbol)}`, + ); + + const { sourceChains, source } = asset('dot'); + console.log( + `The supported source chains are: ${sourceChains.map( + (chain) => chain.name, + )}`, + ); + + const { destinationChains, destination } = source('polkadot'); + console.log( + `The supported destination chains are: ${destinationChains.map( + (chain) => chain.name, + )}`, + ); + + const { accounts } = destination('moonbeam'); + const data = await accounts( + pair.address, + evmSigner.address, // If using viem, use evmSigner.account.address + { + evmSigner, + polkadotSigner: pair, + }, + ); +}; + +fromPolkadot(); +``` + +!!! note + For more information on each of the `Sdk().assets()` builder functions, including the parameters and returned data, please refer to the [XCM SDK Reference](./reference/methods.md#build-the-transfer-data-starting-with-assets){target=\_blank}. + +If you don't need any of the asset or chain information, you can use the `getTransferData` function: + +```js +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); + +const fromPolkadot = async () => { + const data = await sdkInstance.getTransferData({ + destinationAddress: evmSigner.address, // If using viem, use evmSigner.account.address + destinationKeyOrChain: 'moonbeam', + keyOrAsset: 'dot', + polkadotSigner: pair, + sourceAddress: pair.address, + sourceKeyOrChain: 'polkadot', + evmSigner, + }); +}; + +fromPolkadot(); +``` + +!!! note + For more information on the `Sdk().getTransferData()` function, including the parameters and returned data, please refer to the [XCM SDK Reference](./reference/methods.md#the-get-transfer-data-method){target=\_blank}. + +As previously mentioned, the same output will be generated regardless of which method you use to build the transfer data. + +??? code "Example response" + + ```js + // Send DOT from Polkadot to Moonbeam + // data + { + destination: { + balance: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: l { + ecosystem: 'polkadot', + isTestChain: false, + key: 'moonbeam', + name: 'Moonbeam', + type: 'evm-parachain', + assetsData: [Map], + genesisHash: '0xfe58ea77779b7abda7da4ec526d14db9b1e9cd40a217c34892af80a9b332b76d', + parachainId: 2004, + ss58Format: 1284, + usesChainDecimals: false, + weight: 1000000000, + ws: 'wss://wss.api.moonbeam.network', + id: 1284, + rpc: 'https://rpc.api.moonbeam.network' + }, + existentialDeposit: e { + key: 'glmr', + originSymbol: 'GLMR', + amount: 0n, + decimals: 18, + symbol: 'GLMR' + }, + fee: e { + key: 'dot', + originSymbol: 'DOT', + amount: 33068783n, + decimals: 10, + symbol: 'DOT' + }, + min: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + }, + getEstimate: [Function: getEstimate], + isSwapPossible: true, + max: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: e { + key: 'dot', + originSymbol: 'DOT', + amount: 33068783n, + decimals: 10, + symbol: 'DOT' + }, + source: { + balance: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: m { + ecosystem: 'polkadot', + isTestChain: false, + key: 'polkadot', + name: 'Polkadot', + type: 'parachain', + assetsData: Map(0) {}, + genesisHash: '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3', + parachainId: 0, + ss58Format: 0, + usesChainDecimals: false, + weight: 1000000000, + ws: 'wss://rpc.polkadot.io' + }, + destinationFeeBalance: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + existentialDeposit: e { + key: 'dot', + originSymbol: 'DOT', + amount: 10000000000n, + decimals: 10, + symbol: 'DOT' + }, + fee: e { + key: 'dot', + originSymbol: 'DOT', + amount: 169328990n, + decimals: 10, + symbol: 'DOT' + }, + feeBalance: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + max: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + }, + swap: [AsyncFunction: swap], + transfer: [AsyncFunction: transfer] + } + ``` + +As you may have noticed in the example response, the transfer data contains information on the asset, source, and destination chain. In addition, a few functions have been exposed: + +- [`swap`](./reference/methods.md#the-swap-method) - returns the transfer data necessary to swap the asset from the destination chain back to the source chain +- [`transfer`](./reference/methods.md#the-transfer-method) - transfers a given amount of the asset from the source chain to the destination chain +- [`getEstimate`](./reference/methods.md#the-get-estimate-method) - returns an estimated amount of the asset that will be received on the destination chain, less any destination fees + +## Transfer an Asset {: #transfer-an-asset } + +Now that you've built the transfer data, you can transfer the asset from the source chain to the destination chain. To do so, you can use the [`transfer`](./reference/methods.md#the-transfer-method) function, but first, you'll need to specify an amount to send. You can specify the amount in integer or decimal format. For example, if you wanted to send 0.1 DOT, you could use `1000000000n` or `'0.1'`. You can use [asset conversion methods](./reference/methods.md#asset-utilities){target=\_blank}, like [`toDecimal`](./reference/methods.md#the-to-decimal-method) to convert the asset to decimal format. + +For this example, you can transfer twice the minimum amount required of DOT: + +```js +... + +const amount = data.min.toDecimal() * 2; +console.log(`Sending from ${data.source.chain.name} amount: ${amount}`); +const hash = await data.transfer(amount); +console.log(`${data.source.chain.name} tx hash: ${hash}`); +``` + +As the above snippet shows, the `transfer` function returns a transaction hash on the source chain. + +!!! note + For more information on the parameters and returned data for `transfer`, please refer to the [XCM SDK Reference](./reference/methods.md#the-transfer-method){target=\_blank}. + +## Swap an Asset {: #swap-an-asset} + +To swap an asset, you can use the same transfer data and call `data.swap()` to switch the source and destination chain information. You can call the `transfer` function to execute the swap from there. + +```js +... + +const swapData = await data.swap(); +const amount = swapData.min.toDecimal() * 2; +console.log(`Sending from ${swapData.source.chain.name} amount: ${amount}`); +const hash = await swapData.transfer(amount); +console.log(`${swapData.source.chain.name} tx hash: ${hash}`); +``` + +The `swap` function returns the transfer data with the original source chain and destination chains swapped. Using the previous example of sending DOT from Polkadot to Moonbeam, the swap transfer data would send DOT from Moonbeam to Polkadot. + +??? code "Example response" + + ```js + // swapData + { + destination: { + balance: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: m { + ecosystem: 'polkadot', + isTestChain: false, + key: 'polkadot', + name: 'Polkadot', + type: 'parachain', + assetsData: Map(0) {}, + genesisHash: '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3', + parachainId: 0, + ss58Format: 0, + usesChainDecimals: false, + weight: 1000000000, + ws: 'wss://rpc.polkadot.io' + }, + existentialDeposit: e { + key: 'dot', + originSymbol: 'DOT', + amount: 10000000000n, + decimals: 10, + symbol: 'DOT' + }, + fee: e { + key: 'dot', + originSymbol: 'DOT', + amount: 169328990n, + decimals: 10, + symbol: 'DOT' + }, + feeBalance: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + max: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + }, + getEstimate: [Function: getEstimate], + isSwapPossible: true, + max: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: e { + key: 'dot', + originSymbol: 'DOT', + amount: 33068783n, + decimals: 10, + symbol: 'DOT' + }, + source: { + balance: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: l { + ecosystem: 'polkadot', + isTestChain: false, + key: 'moonbeam', + name: 'Moonbeam', + type: 'evm-parachain', + assetsData: [Map], + genesisHash: '0xfe58ea77779b7abda7da4ec526d14db9b1e9cd40a217c34892af80a9b332b76d', + parachainId: 2004, + ss58Format: 1284, + usesChainDecimals: false, + weight: 1000000000, + ws: 'wss://wss.api.moonbeam.network', + id: 1284, + rpc: 'https://rpc.api.moonbeam.network' + }, + destinationFeeBalance: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + existentialDeposit: e { + key: 'glmr', + originSymbol: 'GLMR', + amount: 0n, + decimals: 18, + symbol: 'GLMR' + }, + fee: e { + key: 'dot', + originSymbol: 'DOT', + amount: 33068783n, + decimals: 10, + symbol: 'DOT' + }, + min: e { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + }, + swap: [AsyncFunction: swap], + transfer: [AsyncFunction: transfer] + } + ``` + +!!! note + For more information on the parameters and returned data for `swap`, please refer to the [XCM SDK Reference](./reference/methods.md#the-swap-method){target=\_blank}. + +## Get an Estimate of the Asset to Be Received on the Destination Chain {: #get-estimate } + +When you send an XCM message, you typically pay fees on the destination chain to execute the XCM instructions. Before you transfer the asset, you can use the [`getEstimate`](./reference/methods.md#the-get-estimate-method) function to calculate an estimated amount of the asset that will be received on the destination chain minus any fees. + +The `getEstimate` function is tied to a specific transfer request as it is based on the asset being transferred and the destination chain fees, so you'll need to create the [transfer data](#build-xcm-transfer-data) first. + +You must provide the amount to be transferred to the `getEstimate` function. In the following example, you'll get the estimated amount of DOT that will be received on Moonbeam when 0.1 DOT is transferred. You can specify the amount in integer (`1000000000n`) or decimal (`'0.1'`) format. + +```js +... + +const amount = '0.1'; +const estimatedAmount = data.getEstimate(amount); + +console.log( + `The estimated amount of ${ + data.source.balance.originSymbol + } to be received on ${ + data.destination.chain.name + } is: ${estimatedAmount.toDecimal()} ${data.destination.balance.symbol}` +); +``` + +The `getEstimate` function returns the estimated amount along with information on the asset being transferred. + +??? code "Example response" + + ```js + // estimatedAmount + { + key: 'dot', + originSymbol: 'DOT', + amount: 966931217n, + decimals: 10, + symbol: 'DOT' + } + ``` + +!!! note + For more information on the parameters and returned data for `getEstimate`, please refer to the [XCM SDK Reference](./reference/methods.md#the-get-estimate-method){target=\_blank}. + +## Get Transfer Minimum and Maximum Amounts {: #transfer-min-max-amounts } + +You can use [transfer data](#build-xcm-transfer-data) to retrieve the minimum and maximum amount of an asset that can be transferred. To do so, you'll access the `min` and `max` properties of the asset being transferred: + +=== "Minimum" + + ```js + ... + + const amount = data.min.toDecimal(); + const symbol = data.min.originSymbol; + + console.log(`You can send min: ${amount} ${symbol}`); + ``` + +=== "Maximum" + + ```js + ... + + const amount = data.max.toDecimal(); + const symbol = data.max.originSymbol; + + console.log(`You can send max: ${amount} ${symbol}`); + ``` + +The `min` and `max` properties return the minimum and maximum amount of the asset that can be transferred, along with information on the asset. If the source account does not hold a balance of the chosen asset, the `data.max` amount will be `0n`. + +??? code "Example response" + + ```js + // data.min + { + key: 'dot', + originSymbol: 'DOT', + amount: 33068783n, + decimals: 10, + symbol: 'DOT' + } + // data.max + { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + ``` + +!!! note + For more information on assets and asset amounts, please refer to the [XCM SDK Reference](./reference/interfaces.md#assets){target=\_blank}. + +## Get Transfer Fees {: #get-transfer-fees } + +The [transfer data](#build-xcm-transfer-data) provides information on transfer fees for the source and destination chains. You can retrieve the fees using the following snippet: + +```js +... +const sourceChain = data.source.chain.name; +const sourceFee = data.source.fee; + +const destinationChain = data.destination.chain.name; +const destinationFee = data.destination.fee; + +console.log( + `You will pay ${sourceFee.toDecimal()} ${ + sourceFee.symbol + } fee on ${ + sourceChain + } and ${destinationFee.toDecimal()} ${ + destinationFee.symbol + } fee on ${destinationChain}.` +); +``` + +The `fee` property returns the fees to be paid along with information on the asset. + +??? code "Example response" + + ```js + // sourceFee + { + key: 'dot', + originSymbol: 'DOT', + amount: 169328990n, + decimals: 10, + symbol: 'DOT' + } + // destinationFee + { + key: 'dot', + originSymbol: 'DOT', + amount: 33068783n, + decimals: 10, + symbol: 'DOT' + } + ``` + +!!! note + For more information on assets and asset amounts, including fees, please refer to the [XCM SDK Reference](./reference/interfaces.md#assets){target=\_blank}. + +--8<-- 'text/third-party-content.md' diff --git a/mkdocs/docs/index.md b/mkdocs/docs/index.md new file mode 100644 index 00000000..bfe4eaa2 --- /dev/null +++ b/mkdocs/docs/index.md @@ -0,0 +1,8 @@ +--- +title: Home +description: Discover comprehensive guides and examples for integrating your dApp with the Moonbeam Foundation's XCM SDK, enabling seamless cross-chain communication. +template: home.html +hide: + - navigation + - toc +--- diff --git a/mkdocs/docs/reference/.pages b/mkdocs/docs/reference/.pages new file mode 100644 index 00000000..2d90e78b --- /dev/null +++ b/mkdocs/docs/reference/.pages @@ -0,0 +1,3 @@ +nav: + - 'Types and Interfaces': 'interfaces.md' + - 'Methods': 'methods.md' diff --git a/mkdocs/docs/reference/interfaces.md b/mkdocs/docs/reference/interfaces.md new file mode 100644 index 00000000..19fd5509 --- /dev/null +++ b/mkdocs/docs/reference/interfaces.md @@ -0,0 +1,839 @@ +--- +title: XCM SDK Reference - Interfaces - v2 +description: A reference for the types and interfaces in the Moonbeam XCM SDK that can be used to send XCM transfers between chains within the Polkadot/Kusama ecosystems. +--- + +# Moonbeam XCM SDK Reference: Types and Interfaces + +The XCM SDK is based on defining an asset to transfer, then the source chain to send the asset from, and the destination chain to send the asset to, which, together, build the transfer data. + +The following sections cover the types and interfaces you'll encounter when working with assets, chains, and transfer data. + +## Assets + +### The Asset Object + +
+
+Defines an asset's key and symbol used on the asset's origin chain. + +**Attributes** + +- `key` ++"string"++ - Identifies an asset +- `originSymbol` ++"string"++ - The symbol of the asset on the asset's origin chain + +
+ +```js title="Example" +// The Asset object +// For GLMR on Moonbeam +{ + key: 'glmr', + originSymbol: 'GLMR' +} +``` + +
+ +--- + +### The Asset Amount Object + +
+
+Defines properties related to an asset, including `Asset` properties, the decimals and symbol of the asset, and the amount an associated source or destination address has of the asset. + +!!! note + A few utility methods are available for working with the `AssetAmount` class that converts the amount to various formats. Please refer to the [Methods for Asset Conversions](./methods.md#asset-utilities) section. + +**Attributes** + +- `key` ++"string"++ - Identifies an asset +- `originSymbol` ++"string"++ - The symbol of the asset on the asset's origin chain +- `amount` ++"bigint"++ - Identifies a particular amount of the asset (i.e., balance, minimum, maximum, etc.) +- `decimals` ++"number"++ - The number of decimals the asset has +- `symbol` ++"string"++ - The symbol of the asset + +
+ +```js title="Example" +// The Asset Amount object +// For GLMR on Moonbeam +{ + key: 'glmr', + originSymbol: 'GLMR', + amount: 0n, + decimals: 18, + symbol: 'GLMR' +} +``` + +
+ +--- + +## Chains + +### The Ecosystem Type + +
+
+Specifies the relay chain ecosystem a chain belongs to. Can be any of the following ecosystems as defined by the `Ecosystem` enum: + +```ts +enum Ecosystem { + Polkadot = 'polkadot', + Kusama = 'kusama', + AlphanetRelay = 'alphanet-relay', +} +``` + +
+ +```js title="Example" +// The Ecosystem Type +{ + ecosystem: 'polkadot', +} +``` + +
+ +--- + +### The Chain Type + +
+
+Specifies what kind of parachain a chain is. + +```ts +enum ChainType { + 'Parachain' = 'parachain', + 'EvmParachain' = 'evm-parachain', +} +``` + +
+ +```js title="Example" +// The Chain Type +{ + type: 'evm-parachain', +} +``` + +
+ +--- + +### The Chain Asset ID Type + +
+
+A generic type used to specify the location of the asset on the chain, which is different on every chain. + +```ts +type ChainAssetId = string | number | bigint | { [key: string]: ChainAssetId }; +``` + +
+ +```js title="Example" +// The Chain Asset ID Type +// To target DOT on Moonbeam +{ + id: '42259045809535163221576417993425387648', +} +``` + +
+ +--- + +### The Chain Object + +
+
+Defines properties related to a chain and is used to define the source and destination chains. If a chain is an EVM parachain, there are a couple of additional properties. + +**Attributes** + +- `ecosystem` ++"Ecosystem"++ [:material-link-variant:](#the-ecosystem-type) - Identifies the ecosystem the chain belongs to: `polkadot`, `kusama`, or `alphanet-relay` +- `isTestChain` ++"boolean"++ - Whether the chain is a testnet +- `key` ++"string"++ - Identifies a chain +- `name` ++"string"++ - The name of the chain +- `type` ++"ChainType"++ [:material-link-variant:](#the-chain-type) - The type of the chain: `parachain` or `evm-parachain` +- `assetsData` ++"Map"++ [:material-link-variant:](#the-chain-assets-data-object) - A list of the assets that the chain supports +- `genesisHash` ++"string"++ - The hash of the genesis block +- `parachainId` ++"number"++ - The ID of the parachain (not the EVM chain ID) +- `ss58Format` ++"number"++ - The [ss58 format](https://polkadot.js.org/docs/keyring/start/ss58/){target=\_blank} for the chain +- `usesChainDecimals` ++"boolean"++ - A flag indicating if the chain uses its own decimals in balance queries for all the assets. defaults to `false` +- `ws` ++"string"++ - The WebSocket endpoint for the chain +- `id` ++"number"++ - **For EVM parachains only** - The chain ID +- `rpc` ++"string"++ - **For EVM parachains only** - The HTTP RPC endpoint for the chain + +
+ +```js title="Example" +// The Chain object +// Moonbeam's Chain Object +{ + ecosystem: 'polkadot', + isTestChain: false, + key: 'moonbeam', + name: 'Moonbeam', + type: 'evm-parachain', + assetsData: [Map], + genesisHash: '0xfe58ea77779b7abda7da4ec526d14db9b1e9cd40a217c34892af80a9b332b76d', + parachainId: 2004, + ss58Format: 1284, + usesChainDecimals: false, + weight: 1000000000, + ws: 'wss://wss.api.moonbeam.network', + id: 1284, + rpc: 'https://rpc.api.moonbeam.network' +} +``` + +
+ +--- + +### The Chain Assets Data Object + +
+
+Defines the information needed to target the asset on the chain. This is mostly for internal usage to accommodate how chains store their assets. The SDK defaults to the asset ID if certain properties do not apply to the given chain. + +**Attributes** + +- `asset` ++"Asset"++ - The asset's key and origin symbol +- `balanceId` ++"ChainAssetId"++ [:material-link-variant:](#the-chain-asset-id-type) - The balance ID of the asset. Defaults to the asset ID +- `decimals` ++"number"++ - The number of decimals the asset has +- `id` ++"ChainAssetId"++ [:material-link-variant:](#the-chain-asset-id-type) - The asset ID +- `metadataId` ++"ChainAssetId"++ [:material-link-variant:](#the-chain-asset-id-type) - The metadata ID of the asset +- `minId` ++"ChainAssetId"++ [:material-link-variant:](#the-chain-asset-id-type) - The minimum ID of the asset +- `palletInstance` ++"number"++ - The number of the pallet instance the asset belongs to +- `min` ++"number"++ - The minimum amount of the asset that is required to be left in the account for it to be active. Similar to the existential deposit, except it is for non-native assets + +
+ +```js title="Example" +// The Chain Assets Data object +// To target DOT on Moonbeam +{ + asset: dot, + id: '42259045809535163221576417993425387648', +} +``` + +
+ +--- + +## Transfer Data + +### The Transfer Data Object + +
+
+Defines the complete transfer data for transferring an asset, including asset, source chain, and destination chain information, as well as a few helper functions for the transfer process. + +**Attributes** + +- `destination` ++"DestinationChainTransferData"++ [:material-link-variant:](#the-destination-chain-transfer-data-object) - The assembled destination chain and address information +- `getEstimate` ++"function"++ [:material-link-variant:](./methods.md#the-get-estimate-method) - Gets the estimated amount of the asset that the destination address will receive +- `isSwapPossible` ++"boolean"++ - Returns whether or not the swap is possible +- `max` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The maximum amount of the asset that _can_ be transferred +- `min` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The minimum amount of the asset that _can_ be transferred +- `source` ++"SourceChainTransferData"++ [:material-link-variant:](#the-source-chain-transfer-data-object) - The assembled source chain and address information +- `swap` ++"function"++ [:material-link-variant:](./methods.md#the-swap-method) - Swaps the destination and the source chains and returns the swapped transfer data +- `transfer` ++"function"++ [:material-link-variant:](./methods.md#the-transfer-method) - Transfers a given amount of the asset from the source chain to the destination chain + +
+ +```js title="Example" +// The Transfer Data object +// For sending DOT from Polkadot to Moonbeam +{ + destination: { + balance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: { + ecosystem: 'polkadot', + isTestChain: false, + key: 'moonbeam', + name: 'Moonbeam', + type: 'evm-parachain', + assetsData: [Map], + genesisHash: '0xfe58ea77779b7abda7da4ec526d14db9b1e9cd40a217c34892af80a9b332b76d', + parachainId: 2004, + ss58Format: 1284, + usesChainDecimals: false, + weight: 1000000000, + ws: 'wss://wss.api.moonbeam.network', + id: 1284, + rpc: 'https://rpc.api.moonbeam.network' + }, + existentialDeposit: { + key: 'glmr', + originSymbol: 'GLMR', + amount: 0n, + decimals: 18, + symbol: 'GLMR' + }, + fee: { + key: 'dot', + originSymbol: 'DOT', + amount: 33068783n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + }, + getEstimate: [Function: getEstimate], + isSwapPossible: true, + max: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 33068783n, + decimals: 10, + symbol: 'DOT' + }, + source: { + balance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: { + ecosystem: 'polkadot', + isTestChain: false, + key: 'polkadot', + name: 'Polkadot', + type: 'parachain', + assetsData: Map(0) {}, + genesisHash: '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3', + parachainId: 0, + ss58Format: 0, + usesChainDecimals: false, + weight: 1000000000, + ws: 'wss://rpc.polkadot.io' + }, + destinationFeeBalance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + existentialDeposit: { + key: 'dot', + originSymbol: 'DOT', + amount: 10000000000n, + decimals: 10, + symbol: 'DOT' + }, + fee: { + key: 'dot', + originSymbol: 'DOT', + amount: 169328990n, + decimals: 10, + symbol: 'DOT' + }, + feeBalance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + max: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + }, + swap: [AsyncFunction: swap], + transfer: [AsyncFunction: transfer] +} +``` + +
+ +--- + +### The Destination Chain Transfer Data Object + +
+
+Defines the destination chain data for the transfer. + +**Attributes** + +- `balance` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The balance of the asset being transferred on the destination address +- `chain` ++"AnyChain"++ [:material-link-variant:](#the-chain-object) - The destination chain information +- `existentialDeposit` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The existential deposit for the asset being transferred on the destination chain +- `fee` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The amount of fees for the asset being transferred on the destination chain +- `min` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The minimum amount of the asset to transfer. This is different than `TransferData.min`, as this dictates the minimum amount that should be received on the destination chain + +
+ +```js title="Example" +// The Destination Chain Transfer Data object +// For sending DOT from Polkadot to Moonbeam +{ + balance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: { + ecosystem: 'polkadot', + isTestChain: false, + key: 'moonbeam', + name: 'Moonbeam', + type: 'evm-parachain', + assetsData: [Map], + genesisHash: '0xfe58ea77779b7abda7da4ec526d14db9b1e9cd40a217c34892af80a9b332b76d', + parachainId: 2004, + ss58Format: 1284, + usesChainDecimals: false, + weight: 1000000000, + ws: 'wss://wss.api.moonbeam.network', + id: 1284, + rpc: 'https://rpc.api.moonbeam.network' + }, + existentialDeposit: { + key: 'glmr', + originSymbol: 'GLMR', + amount: 0n, + decimals: 18, + symbol: 'GLMR' + }, + fee: { + key: 'dot', + originSymbol: 'DOT', + amount: 33068783n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } +} +``` + +
+ +--- + +### The Source Chain Transfer Data Object + +
+
+Defines the source chain data for the transfer. + +**Attributes** + +- `balance` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The balance of the asset being transferred for the source address +- `chain` ++"AnyChain"++ [:material-link-variant:](#the-chain-object) - The source chain information +- `destinationFeeBalance` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The balance of the asset used to pay for fees in the destination chain +- `existentialDeposit` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The existential deposit for the asset being transferred on the source chain +- `fee` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The amount of fees for the asset being transferred on the source chain +- `feeBalance` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The balance of the asset being transferred on the source chain +- `min` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The minimum amount of the asset that should be kept on the source chain, taking into consideration the `existentialDeposit` and `fee` for the transfer +- `max` ++"AssetAmount"++ [:material-link-variant:](#the-asset-amount-object) - The maximum amount of the asset that _can_ be transferred + +
+ +```js title="Example" +// The Source Chain Transfer Data object +// For sending DOT from Polkadot to Moonbeam +{ + balance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: { + ecosystem: 'polkadot', + isTestChain: false, + key: 'polkadot', + name: 'Polkadot', + type: 'parachain', + assetsData: Map(0) {}, + genesisHash: '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3', + parachainId: 0, + ss58Format: 0, + usesChainDecimals: false, + weight: 1000000000, + ws: 'wss://rpc.polkadot.io' + }, + destinationFeeBalance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + existentialDeposit: { + key: 'dot', + originSymbol: 'DOT', + amount: 10000000000n, + decimals: 10, + symbol: 'DOT' + }, + fee: { + key: 'dot', + originSymbol: 'DOT', + amount: 169328990n, + decimals: 10, + symbol: 'DOT' + }, + feeBalance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + max: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } +} +``` + +
+ +--- + +## SDK Options + +### The SDK Options Object + +
+
+Defines options to initialize the SDK, including EVM and Polkadot signers and a custom configuration service. + +**Attributes** + +- `evmSigner` ++"EvmSigner"++ [:material-link-variant:](#the-evm-signer-type) - The signer for transfers involving EVM chains +- `polkadotSigner` ++"Signer | IKeyringPair"++ [:material-link-variant:](#the-polkadot-signer-type) - The signer for transfers involving non-EVM chains +- `configService` ++"IConfigService"++ [:material-link-variant:](#the-config-service-object) - The custom configuration service + +
+ +```js title="Example" +// The Sdk Options object +{ + evmSigner: INSERT_EVM_SIGNER, + polkadotSigner: INSERT_POLKADOT_SIGNER, + configService: { + assets: INSERT_ASSETS_MAPPING, + chains: INSERT_CHAINS_MAPPING, + chainsConfig: INSERT_CHAIN_CONFIG_MAPPING, + } +} +``` + +
+ +--- + +## Signers + +### The EVM Signer Type + +
+
+Defines the EVM signer for transfers involving EVM chains. Can be an [Ethers signer](https://docs.ethers.org/v6/api/wallet/#Wallet) or [viem Wallet Client](https://viem.sh/docs/clients/wallet). + +
+ +```js title="Example" +import { ethers } from 'ethers'; + +const provider = new ethers.WebSocketProvider( + 'wss://wss.api.moonbeam.network', + { + chainId: 1284, + name: 'moonbeam', + }, +); +const evmSigner = new ethers.Wallet('INSERT_PRIVATE_KEY', provider); +``` + +
+ +--- + +### The Polkadot Signer Type + +
+
+Defines the signer for transfers involving non-EVM chains. Can be a [signer](https://github.com/polkadot-js/api/blob/v11.0.2/packages/types/src/types/extrinsic.ts#L135) or a [Keyring pair](https://polkadot.js.org/docs/keyring/start/create). + +
+ +```js title="Example" +import { Keyring } from '@polkadot/api'; +import { cryptoWaitReady } from '@polkadot/util-crypto'; + +await cryptoWaitReady(); +const keyring = new Keyring({ type: 'sr25519' }); +const pair = keyring.addFromUri('INSERT_MNEMONIC'); +``` + +
+ +--- + +## Configurations + +The interfaces in this section are primarily used for defining your own custom configuration source and adding or updating new asset and chain configurations to the XCM SDK. To learn how to add new configurations, please refer to the [Contribute to the XCM SDK](./../contribute.md) guide. + +### The Config Service Object + +
+
+Defines a custom configuration service. This overrides the asset and chain configurations in the [xcm-config package](https://github.com/moonbeam-foundation/xcm-sdk/tree/main/packages/config){target=\_blank}, which is exposed by default by the SDK. + +**Attributes** + +- `assets` ++"Map"++ [:material-link-variant:](#the-asset-object) - A list of the supported assets mapping each asset key to its corresponding `Asset` object +- `chains` ++"Map"++ [:material-link-variant:](#the-chain-object) - A list of the supported assets mapping each chain key to its corresponding `Chain` object +- `chainsConfig` ++"Map"++ [:material-link-variant:](#the-chain-config-object) - A list of the supported chain configurations mapping each chain key to its corresponding `ChainConfig` object + +
+ +```js title="Example" +import { Keyring } from '@polkadot/api'; +import { cryptoWaitReady } from '@polkadot/util-crypto'; + +await cryptoWaitReady(); +const keyring = new Keyring({ type: 'sr25519' }); +const pair = keyring.addFromUri('INSERT_MNEMONIC'); +``` + +
+ +--- + +### The Chain Config Object + +
+
+Defines a chain's configurations, including information for each chain's supported assets. + +**Attributes** + +- `assets` ++"AssetConfig[]"++ [:material-link-variant:](#the-asset-object) - The supported asset configurations +- `chain` ++"AnyChain"++ [:material-link-variant:](#the-chain-object) - The chain's properties + +
+ +```js title="Example" +// The Chain Config object +// For configuring the Polkadot Asset Hub +{ + assets: [ + ...new AssetConfig({ + asset: usdt, + balance: BalanceBuilder().substrate().assets().account(), + destination: moonbeam, + destinationFee: { + amount: FeeBuilder().assetManager().assetTypeUnitsPerSecond(), + asset: usdt, + balance: BalanceBuilder().substrate().assets().account(), + }, + extrinsic: ExtrinsicBuilder() + .polkadotXcm() + .limitedReserveTransferAssets() + .X2(), + fee: { + asset: dot, + balance: BalanceBuilder().substrate().system().account(), + xcmDeliveryFeeAmount, + }, + min: AssetMinBuilder().assets().asset(), + }), + ... + ], + chain: new Parachain({ + assetsData: [ + { + asset: usdt, + id: 1984, + palletInstance: 50, + }, + ... + ], + ecosystem: Ecosystem.Polkadot, + genesisHash: + '0x68d56f15f85d3136970ec16946040bc1752654e906147f7e43e9d539d7c3de2f', + key: 'Polkadot-asset-hub', + name: 'Polkadot Asset Hub', + parachainId: 1000, + ss58Format: 42, + ws: 'wss://polkadot-asset-hub-rpc.polkadot.io', + }) +} +``` + +
+ +--- + +### The Asset Config Object + +
+
+Defines an asset's configurations for a source chain and includes information about the destination chain, associated fees for transferring the asset from the source chain to the destination chain, and builder functions that define how to transfer the asset. + +**Attributes** + +- `asset` ++"Asset"++ [:material-link-variant:](#the-asset-object) - The asset's key and origin symbol +- `balance` ++"BalanceConfigBuilder"++ [:material-link-variant:](https://github.com/moonbeam-foundation/xcm-sdk/blob/@moonbeam-network/xcm-sdk@2.2.3/packages/builder/src/balance/BalanceBuilder.interfaces.ts){target=\_blank} - The query builder for retrieving the balance of an asset for a given account +- `contract` ++"ContractConfigBuilder"++ [:material-link-variant:](https://github.com/moonbeam-foundation/xcm-sdk/blob/@moonbeam-network/xcm-sdk@2.2.3/packages/builder/src/contract/ContractBuilder.interfaces.ts){target=\_blank} - The contract call builder for a cross-chain transfer. This is specific to EVM chains that use contracts to interact with Substrate pallets for cross-chain transfers, such as [Moonbeam's X-Tokens precompiled contract](https://docs.moonbeam.network/builders/interoperability/xcm/xc20/send-xc20s/xtokens-precompile/) +- `destination` ++"AnyChain"++ [:material-link-variant:](#the-chain-object) - The destination chain information +- `destinationFee` ++"DestinationFeeConfig"++ - The destination chain fees +- `extrinsic` ++"ExtrinsicConfigBuilder"++ [:material-link-variant:](https://github.com/moonbeam-foundation/xcm-sdk/blob/@moonbeam-network/xcm-sdk@2.2.3/packages/builder/src/extrinsic/ExtrinsicBuilder.interfaces.ts){target=\_blank} - The extrinsic builder for a cross-chain transfer +- `fee` ++"FeeAssetConfig"++ [:material-link-variant:](#the-fee-asset-config) - The source chain fees +- `min` ++"AssetMinConfigBuilder"++ [:material-link-variant:](https://github.com/moonbeam-foundation/xcm-sdk/blob/@moonbeam-network/xcm-sdk@2.2.3/packages/builder/src/asset-min/AssetMinBuilder.interfaces.ts){target=\_blank} - The query builder for retrieving the minimum amount of an asset required to be left in an account + +
+ +```js title="Example" +// The Asset Config object +// For configuring USDT to be sent from +// the Polkadot Asset Hub to Moonbeam +{ + asset: usdt, + balance: BalanceBuilder().substrate().assets().account(), + destination: moonbeam, + destinationFee: { + amount: FeeBuilder().assetManager().assetTypeUnitsPerSecond(), + asset: usdt, + balance: BalanceBuilder().substrate().assets().account(), + }, + extrinsic: ExtrinsicBuilder() + .polkadotXcm() + .limitedReserveTransferAssets() + .X2(), + fee: { + asset: dot, + balance: BalanceBuilder().substrate().system().account(), + xcmDeliveryFeeAmount, + }, + min: AssetMinBuilder().assets().asset(), +} +``` + +
+ +--- + +### The Fee Asset Config + +
+
+Defines the fees for a particular asset on the source chain. + +**Attributes** + +- `asset` ++"Asset"++ [:material-link-variant:](#the-asset-object) - The asset's key and origin symbol +- `balance` ++"BalanceConfigBuilder"++ [:material-link-variant:](https://github.com/moonbeam-foundation/xcm-sdk/blob/@moonbeam-network/xcm-sdk@2.2.3/packages/builder/src/balance/BalanceBuilder.interfaces.ts){target=\_blank} - The query builder for retrieving the balance of an asset for a given account +- `xcmDeliveryFeeAmount` ++"number"++ - The delivery fee amount for the cross-chain transfer + +
+ +```js title="Example" +// The Fee Asset Config object +// For configuring USDT to be sent from +// the Polkadot Asset Hub to Moonbeam +{ + asset: dot, + balance: BalanceBuilder().substrate().system().account(), + xcmDeliveryFeeAmount: 0.036, +} +``` + +
+ +### The Destination Fee Asset Config + +
+
+Defines the fees for a particular asset on the destination chain. + +**Attributes** + +- `asset` ++"Asset"++ [:material-link-variant:](#the-asset-object) - The asset's key and origin symbol +- `balance` ++"BalanceConfigBuilder"++ [:material-link-variant:](https://github.com/moonbeam-foundation/xcm-sdk/blob/@moonbeam-network/xcm-sdk@2.2.3/packages/builder/src/balance/BalanceBuilder.interfaces.ts){target=\_blank} - The query builder for retrieving the balance of an asset for a given account +- `xcmDeliveryFeeAmount` ++"number"++ - The delivery fee amount for the cross-chain transfer +- `amount` ++"number | FeeConfigBuilder"++ [:material-link-variant:](https://github.com/moonbeam-foundation/xcm-sdk/blob/@moonbeam-network/xcm-sdk@2.2.3/packages/builder/src/fee/FeeBuilder.interfaces.ts){target=\_blank} - The fee amount or the query builder for retrieving the fee amount for the execution of the cross-chain transfer + +
+ +```js title="Example" +// The Desintation Fee Asset Config object +// For configuring USDT to be sent from +// the Polkadot Asset Hub to Moonbeam +{ + asset: dot, + balance: BalanceBuilder().substrate().system().account(), + amount: FeeBuilder().assetManager().assetTypeUnitsPerSecond(), +} +``` + +
diff --git a/mkdocs/docs/reference/methods.md b/mkdocs/docs/reference/methods.md new file mode 100644 index 00000000..c7c22936 --- /dev/null +++ b/mkdocs/docs/reference/methods.md @@ -0,0 +1,1365 @@ +--- +title: XCM SDK Reference - Methods - v2 +description: A reference for the available methods in the Moonbeam XCM SDK that can be used to send XCM transfers between chains within the Polkadot/Kusama ecosystems. +--- + +# Moonbeam XCM SDK Reference: Methods + +The SDK provides an API that enables you to get asset information for each supported asset, the source chains where a given asset can be sent from, and, given a source chain, the supported destination chains where the given asset can be sent. The SDK also includes helper methods related to transferring cross-chain assets, such as getting an estimated amount of the asset the destination account will receive, less any execution fees, and asset conversion methods based on the asset and the number of decimals it has. All of these enable you to transfer assets across chains easily and seamlessly. + +The following sections cover the available methods in the XCM SDK. + +## Initialize the SDK + +
+
+ +`Sdk()` - Exposes the methods of the XCM SDK. **Must be called first to access other SDK methods**. + +**Parameters** + +- `options?` ++"SdkOptions"++ - Allows you to specify an `evmSigner` or `polkadotSigner` + +**Returns** + +- `assets` ++"function"++ [:material-link-variant:](#the-assets-method) - Provides an entry point to building the data necessary to transfer an asset between a source chain and a destination chain +- `getTransferData` ++"function"++ [:material-link-variant:](#the-get-transfer-data-method) - Builds the data necessary to transfer an asset between a source chain and a destination chain + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +console.log(sdkInstance); +``` + +```js title="Response" +{ + assets: [Function: assets], + getTransferData: [AsyncFunction: getTransferData] +} +``` + +
+
+ +--- + +### The Get Transfer Data Method + +
+
+ +`getTransferData()` - Builds the data necessary to transfer an asset between a source chain and a destination chain. + +**Parameters** + +- `destinationAddress` ++"string"++ - The address of the receiving account on the destination chain +- `destinationKeyorChain` ++"string | AnyChain"++ [:material-link-variant:](./interfaces.md#the-chain-object) - The key or `Chain` data for the destination chain +- `evmSigner?` ++"EvmSigner"++ [:material-link-variant:](./interfaces.md#the-evm-signer-type) - The signer for Ethereum-compatible chains that use H160 Ethereum-style accounts. Can be an Ethers signer or a viem Wallet Client +- `keyOrAsset` ++"string | Asset"++ [:material-link-variant:](./interfaces.md#the-asset-object) - The key or `Asset` data for the asset being transferred +- `polkadotSigner?` ++"PolkadotSigner | IKeyringPair"++ [:material-link-variant:](./interfaces.md#the-polkadot-signer-type) - The Polkadot signer or Keyring pair +- `sourceAddress` ++"string"++ - The address of the sending account on the source chain +- `sourceKeyOrChain` ++"string | AnyChain"++ [:material-link-variant:](./interfaces.md#the-chain-object) - The key or `Chain` data for the source chain + +**Returns** + +- ++"Promise"++ - The assembled transfer data, which includes the following: + + - `destination` ++"DestinationChainTransferData"++ [:material-link-variant:](./interfaces.md#the-destination-chain-transfer-data-object) - The assembled destination chain and address information + - `getEstimate` ++"function"++ [:material-link-variant:](#the-get-estimate-method) - Gets the estimated amount of the asset that the destination address will receive + - `isSwapPossible` ++"boolean"++ - Returns whether or not the swap is possible + - `max` ++"AssetAmount"++ [:material-link-variant:](./interfaces.md#the-asset-amount-object) - The maximum amount of the asset that can be transferred + - `min` ++"AssetAmount"++ [:material-link-variant:](./interfaces.md#the-asset-amount-object) - The minimum amount of the asset that can be transferred + - `source` ++"SourceChainTransferData"++ [:material-link-variant:](./interfaces.md#the-source-chain-transfer-data-object) - The assembled source chain and address information + - `swap` ++"function"++ [:material-link-variant:](#the-swap-method) - Swaps the destination and the source chains and returns the swapped transfer data + - `transfer` ++"function"++ [:material-link-variant:](#the-transfer-method) - Transfers a given amount of the asset from the source chain to the destination chain + +
+
+ +```js title="Example Usage" +const transferData = await Sdk().getTransferData({ + destinationAddress: 'INSERT_MOONBEAM_ADDRESS', + destinationKeyOrChain: 'moonbeam', + evmSigner: INSERT_EVM_SIGNER, + keyOrAsset: 'dot', + polkadotSigner: INSERT_POLKADOT_SIGNER, + sourceAddress: 'INSERT_POLKADOT_ADDRESS', + sourceKeyOrChain: { + key: 'polkadot', + name: 'polkadot', + type: 'parachain', + }, +}); +console.log(transferData); +``` + +```js title="Response" +{ + destination: { + balance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: { + ecosystem: 'polkadot', + isTestChain: false, + key: 'moonbeam', + name: 'Moonbeam', + type: 'evm-parachain', + assetsData: [Map], + genesisHash: '0xfe58ea77779b7abda7da4ec526d14db9b1e9cd40a217c34892af80a9b332b76d', + parachainId: 2004, + ss58Format: 1284, + usesChainDecimals: false, + weight: undefined, + ws: 'wss://wss.api.moonbeam.network', + id: 1284, + rpc: 'https://rpc.api.moonbeam.network' + }, + existentialDeposit: { + key: 'glmr', + originSymbol: 'GLMR', + amount: 0n, + decimals: 18, + symbol: 'GLMR' + }, + fee: { + key: 'dot', + originSymbol: 'DOT', + amount: 20080321n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + }, + getEstimate: [Function: getEstimate], + isSwapPossible: true, + max: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 20080321n, + decimals: 10, + symbol: 'DOT' + }, + source: { + balance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: { + ecosystem: 'polkadot', + isTestChain: false, + key: 'polkadot', + name: 'Polkadot', + type: 'parachain', + assetsData: Map(0) {}, + genesisHash: '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3', + parachainId: 0, + ss58Format: 0, + usesChainDecimals: false, + weight: undefined, + ws: 'wss://polkadot-rpc.dwellir.com' + }, + destinationFeeBalance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + existentialDeposit: { + key: 'dot', + originSymbol: 'DOT', + amount: 10000000000n, + decimals: 10, + symbol: 'DOT' + }, + fee: { + key: 'dot', + originSymbol: 'DOT', + amount: 163633495n, + decimals: 10, + symbol: 'DOT' + }, + feeBalance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + max: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + }, + swap: [AsyncFunction: swap], + transfer: [AsyncFunction: transfer] +} +``` + +
+
+ +--- + +### The Assets Method + +
+
+ +`assets()` - Provides an entry point for building the data necessary to transfer an asset between a source chain and a destination chain. + +**Parameters** + +- `ecosystem?` ++"Ecosystem"++ - Specify the ecosystem for a set of assets: `polkadot`, `kusama`, or `alphanet-relay` + +**Returns** + +- `assets` ++"Asset[]"++ - A list of the supported assets +- `asset` ++"function"++ [:material-link-variant:](#the-asset-method) - Sets the asset to be transferred. Refer to the following section on how to continue to build the transfer data using the `asset` function + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const assets = sdkInstance.assets(); +console.log(assets); +``` + +```js title="Response" +{ + assets: [ + { key: 'aca', originSymbol: 'ACA' }, + { key: 'alan', originSymbol: 'ALAN' }, + { key: 'ampe', originSymbol: 'AMPE' }, + { key: 'aseed', originSymbol: 'aSEED' }, + { key: 'astr', originSymbol: 'ASTR' }, + ... + ], + asset: [Function: asset] +} +``` + +
+
+ +--- + +## Build the Transfer Data Starting with Assets + +When building transfer data with the `Sdk().assets()` function, you'll use multiple methods to build and send the underlying XCM message. + +### The Asset Method + +
+
+ +`asset()` - Sets the asset to be transferred. **Must call `assets()` first**. + +**Parameters** + +- `keyOrAsset` ++"string | Asset"++ [:material-link-variant:](./interfaces.md#the-asset-object) - The key or `Asset` data for the asset being transferred + +**Returns** + +- `sourceChains` ++"AnyChain[]"++ [:material-link-variant:](./interfaces.md#the-chain-object) - A list of the supported source chains for the specified asset +- `source` ++"function"++ [:material-link-variant:](#the-source-method) - Sets the source chain to transfer the asset from + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const sourceData = sdkInstance.assets().asset('dot'); +console.log(sourceData); +``` + +```js title="Response" +{ + sourceChains: [ + { + ecosystem: 'polkadot', + isTestChain: false, + key: 'moonbeam', + name: 'Moonbeam', + type: 'evm-parachain', + assetsData: { + 'aca' => { + asset: { key: 'aca', originSymbol: 'ACA' }, + id: '224821240862170613278369189818311486111' + }, + 'astr' => { + asset: { key: 'astr', originSymbol: 'ASTR' }, + id: '224077081838586484055667086558292981199' + }, + ... + }, + genesisHash: '0xfe58ea77779b7abda7da4ec526d14db9b1e9cd40a217c34892af80a9b332b76d', + parachainId: 2004, + ss58Format: 1284, + usesChainDecimals: false, + weight: undefined, + ws: 'wss://wss.api.moonbeam.network', + id: 1284, + rpc: 'https://rpc.api.moonbeam.network', + nativeCurrency: { + decimals: 18, + name: 'GLMR', + symbol: 'GLMR' + } + }, + { + ecosystem: 'polkadot', + isTestChain: false, + key: 'polkadot', + name: 'Polkadot', + type: 'parachain', + assetsData: Map(0) {}, + genesisHash: '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3', + parachainId: 0, + ss58Format: 0, + usesChainDecimals: false, + weight: undefined, + ws: 'wss://polkadot-rpc.dwellir.com' + } + ], + source: [Function: source] +} +``` + +
+
+ +--- + +### The Source Method + +
+
+ +`source()` - Sets the source chain from which to transfer the asset. **Must call `asset()` first**. + +**Parameters** + +- `keyOrChain` ++"string | AnyChain"++ [:material-link-variant:](./interfaces.md#the-chain-object) - The key or `Chain` data for the source chain + +**Returns** + +- `destinationChains` ++"AnyChain[]"++ [:material-link-variant:](./interfaces.md#the-chain-object) - A list of the supported destination chains for the specified asset and source chain +- `destination` ++"function"++ [:material-link-variant:](#the-destination-method) - Sets the destination chain to transfer the asset from + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const destinationData = sdkInstance.assets().asset('dot').source('polkadot'); +console.log(destinationData); +``` + +```js title="Response" +{ + destinationChains: [ + { + ecosystem: 'polkadot', + isTestChain: false, + key: 'moonbeam', + name: 'Moonbeam', + type: 'evm-parachain', + assetsData: { + 'aca' => { + asset: { key: 'aca', originSymbol: 'ACA' }, + id: '224821240862170613278369189818311486111' + }, + 'astr' => { + asset: { key: 'astr', originSymbol: 'ASTR' }, + id: '224077081838586484055667086558292981199' + }, + ... + }, + genesisHash: '0xfe58ea77779b7abda7da4ec526d14db9b1e9cd40a217c34892af80a9b332b76d', + parachainId: 2004, + ss58Format: 1284, + usesChainDecimals: false, + weight: undefined, + ws: 'wss://wss.api.moonbeam.network', + id: 1284, + rpc: 'https://rpc.api.moonbeam.network', + nativeCurrency: { + decimals: 18, + name: 'GLMR', + symbol: 'GLMR' + } + } + ], + destination: [Function: destination] +} +``` + +
+
+ +--- + +### The Destination Method + +
+
+ +`destination()` - Sets the destination chain to which to transfer the asset. **Must call `source()` first**. + +**Parameters** + +- `keyOrChain` ++"string | AnyChain"++ [:material-link-variant:](./interfaces.md#the-chain-object) - The key or `Chain` data for the destination chain + +**Returns** + +- `accounts` ++"function"++ [:material-link-variant:](#the-accounts-method) - Sets the source address, the destination address, and the signer(s) required for the transfer + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const transferDataWithoutAccounts = sdkInstance + .assets() + .asset('dot') + .source('polkadot') + .destination('moonbeam'); +console.log(transferDataWithoutAccounts); +``` + +```js title="Response" +{ accounts: [AsyncFunction: accounts] } +``` + +
+
+ +--- + +### The Accounts Method + +
+
+ +`accounts()` - Sets the source address, the destination address, and the signer(s) required for the transfer. **Must call `destination()` first**. + +**Parameters** + +- `sourceAddress` ++"string"++ - The address of the sending account on the source chain +- `destinationAddress` ++"string"++ - The address of the receiving account on the destination chain +- `signers?` ++"Partial(signers)"++ [:material-link-variant:](./interfaces.md#signers) - The EVM or Polkadot signers required to sign transactions + +**Returns** + +- ++"Promise"++ - The assembled transfer data, which includes the following: + + - `destination` ++"DestinationChainTransferData"++ [:material-link-variant:](./interfaces.md#the-destination-chain-transfer-data-object) - The assembled destination chain and address information + - `getEstimate` ++"function"++ [:material-link-variant:](#the-get-estimate-method) - Gets the estimated amount of the asset that the destination address will receive + - `isSwapPossible` ++"boolean"++ - Returns whether or not the swap is possible + - `max` ++"AssetAmount"++ [:material-link-variant:](./interfaces.md#the-asset-amount-object) - The maximum amount of the asset that can be transferred + - `min` ++"AssetAmount"++ [:material-link-variant:](./interfaces.md#the-asset-amount-object) - The minimum amount of the asset that can be transferred + - `source` ++"SourceChainTransferData"++ [:material-link-variant:](./interfaces.md#the-source-chain-transfer-data-object) - The assembled source chain and address information + - `swap` ++"function"++ [:material-link-variant:](#the-swap-method) - Swaps the destination and the source chains and returns the swapped transfer data + - `transfer` ++"function"++ [:material-link-variant:](#the-transfer-method) - Transfers a given amount of the asset from the source chain to the destination chain + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const transferData = await sdkInstance + .assets() + .asset('dot') + .source('polkadot') + .destination('moonbeam') + .accounts( + INSERT_POLKADOT_ADDRESS, // Source chain address + INSERT_MOONBEAM_ADDRESS, // Destination chain address + { + evmSigner: INSERT_EVM_SIGNER, + polkadotSigner: INSERT_POLKADOT_SIGNER, + }, + ); +console.log(transferData); +``` + +```js title="Response" +{ + destination: { + balance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: { + ecosystem: 'polkadot', + isTestChain: false, + key: 'moonbeam', + name: 'Moonbeam', + type: 'evm-parachain', + assetsData: [Map], + genesisHash: '0xfe58ea77779b7abda7da4ec526d14db9b1e9cd40a217c34892af80a9b332b76d', + parachainId: 2004, + ss58Format: 1284, + usesChainDecimals: false, + weight: undefined, + ws: 'wss://wss.api.moonbeam.network', + id: 1284, + rpc: 'https://rpc.api.moonbeam.network' + }, + existentialDeposit: { + key: 'glmr', + originSymbol: 'GLMR', + amount: 0n, + decimals: 18, + symbol: 'GLMR' + }, + fee: { + key: 'dot', + originSymbol: 'DOT', + amount: 20080321n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + }, + getEstimate: [Function: getEstimate], + isSwapPossible: true, + max: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 20080321n, + decimals: 10, + symbol: 'DOT' + }, + source: { + balance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: { + ecosystem: 'polkadot', + isTestChain: false, + key: 'polkadot', + name: 'Polkadot', + type: 'parachain', + assetsData: Map(0) {}, + genesisHash: '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3', + parachainId: 0, + ss58Format: 0, + usesChainDecimals: false, + weight: undefined, + ws: 'wss://polkadot-rpc.dwellir.com' + }, + destinationFeeBalance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + existentialDeposit: { + key: 'dot', + originSymbol: 'DOT', + amount: 10000000000n, + decimals: 10, + symbol: 'DOT' + }, + fee: { + key: 'dot', + originSymbol: 'DOT', + amount: 163633495n, + decimals: 10, + symbol: 'DOT' + }, + feeBalance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + max: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + }, + swap: [AsyncFunction: swap], + transfer: [AsyncFunction: transfer] +} +``` + +
+
+ +--- + +## Consume Transfer Data + +### The Swap Method + +
+
+ +`swap()` - Returns the transfer data necessary to swap the asset from the destination chain back to the source chain. + +**Parameters** + +None. + +**Returns** + +- ++"Promise"++ - If the swap is not possible, `undefined` is returned. If the swap is possible, the assembled transfer data is returned, which includes the following: + + - `destination` ++"DestinationChainTransferData"++ [:material-link-variant:](./interfaces.md#the-destination-chain-transfer-data-object) - The assembled destination chain and address information + - `getEstimate` ++"function"++ [:material-link-variant:](#the-get-estimate-method) - Gets the estimated amount of the asset that the destination address will receive + - `isSwapPossible` ++"boolean"++ - Returns whether or not the swap is possible + - `max` ++"AssetAmount"++ [:material-link-variant:](./interfaces.md#the-asset-amount-object) - The maximum amount of the asset that can be transferred + - `min` ++"AssetAmount"++ [:material-link-variant:](./interfaces.md#the-asset-amount-object) - The minimum amount of the asset that can be transferred + - `source` ++"SourceChainTransferData"++ [:material-link-variant:](./interfaces.md#the-source-chain-transfer-data-object) - The assembled source chain and address information + - `swap` ++"function"++ [:material-link-variant:](#the-swap-method) - Swaps the destination and the source chains and returns the swapped transfer data + - `transfer` ++"function"++ [:material-link-variant:](#the-transfer-method) - Transfers a given amount of the asset from the source chain to the destination chain + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const transferData = await sdkInstance + .assets() + .asset('dot') + .source('polkadot') + .destination('moonbeam') + .accounts( + INSERT_POLKADOT_ADDRESS, // Source chain address + INSERT_MOONBEAM_ADDRESS, // Destination chain address + { + evmSigner: INSERT_EVM_SIGNER, + polkadotSigner: INSERT_POLKADOT_SIGNER, + }, + ); + +const swapData = await transferData.swap(); +console.log(swapData); +``` + +```js title="Response" +{ + destination: { + balance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: { + ecosystem: 'polkadot', + isTestChain: false, + key: 'polkadot', + name: 'Polkadot', + type: 'parachain', + assetsData: Map(0) {}, + genesisHash: '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3', + parachainId: 0, + ss58Format: 0, + usesChainDecimals: false, + weight: undefined, + ws: 'wss://polkadot-rpc.dwellir.com' + }, + existentialDeposit: { + key: 'dot', + originSymbol: 'DOT', + amount: 10000000000n, + decimals: 10, + symbol: 'DOT' + }, + fee: { + key: 'dot', + originSymbol: 'DOT', + amount: 520000000n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + }, + getEstimate: [Function: getEstimate], + isSwapPossible: true, + max: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 10520000000n, + decimals: 10, + symbol: 'DOT' + }, + source: { + balance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + chain: { + ecosystem: 'polkadot', + isTestChain: false, + key: 'moonbeam', + name: 'Moonbeam', + type: 'evm-parachain', + assetsData: { + 'aca' => { + asset: { key: 'aca', originSymbol: 'ACA' }, + id: '224821240862170613278369189818311486111' + }, + 'astr' => { + asset: { key: 'astr', originSymbol: 'ASTR' }, + id: '224077081838586484055667086558292981199' + }, + ... + }, + genesisHash: '0xfe58ea77779b7abda7da4ec526d14db9b1e9cd40a217c34892af80a9b332b76d', + parachainId: 2004, + ss58Format: 1284, + usesChainDecimals: false, + weight: undefined, + ws: 'wss://wss.api.moonbeam.network', + id: 1284, + rpc: 'https://rpc.api.moonbeam.network', + nativeCurrency: { + decimals: 18, + name: 'GLMR', + symbol: 'GLMR' + } + }, + destinationFeeBalance: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + existentialDeposit: { + key: 'glmr', + originSymbol: 'GLMR', + amount: 0n, + decimals: 18, + symbol: 'GLMR' + }, + fee: { + key: 'glmr', + originSymbol: 'GLMR', + amount: 0n, + decimals: 18, + symbol: 'GLMR' + }, + feeBalance: { + key: 'glmr', + originSymbol: 'GLMR', + amount: 0n, + decimals: 18, + symbol: 'GLMR' + }, + max: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + }, + min: { + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' + } + }, + swap: [AsyncFunction: swap], + transfer: [AsyncFunction: transfer] +} +``` + +
+
+ +--- + +### The Transfer Method + +
+
+ +`transfer()` - Transfers a given amount of the asset from the source chain to the destination chain. + +**Parameters** + +- `amount` ++"bigint | number| string"++ - The amount of the asset to transfer between the source and destination chains + +**Returns** + +- ++"Promise(string)"++ - The transaction hash for the transfer on the source chain + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const transferData = await sdkInstance + .assets() + .asset('dot') + .source('polkadot') + .destination('moonbeam') + .accounts( + INSERT_POLKADOT_ADDRESS, // Source chain address + INSERT_MOONBEAM_ADDRESS, // Destination chain address + { + evmSigner: INSERT_EVM_SIGNER, + polkadotSigner: INSERT_POLKADOT_SIGNER, + }, + ); + +const transferTxHash = await transferData.transfer(); +console.log(transferTxHash); +``` + +```js title="Response" +0x2a1ec19aa360111c0e499c90b5a2747f2e87f49966e280daf831b856996f3952; +``` + +
+
+ +--- + +### The Get Estimate Method + +
+
+ +`getEstimate()` - Returns an estimated amount of the asset that will be received on the destination chain, less any destination fees. + +**Parameters** + +- `amount` ++"number | string"++ - The amount of the asset to transfer between the source and destination chains + +**Returns** + +- ++"AssetAmount"++ [:material-link-variant:](./interfaces.md#the-asset-amount-object) - An estimated amount of the asset that the destination address will receive + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const transferData = await sdkInstance + .assets() + .asset('dot') + .source('polkadot') + .destination('moonbeam') + .accounts( + INSERT_POLKADOT_ADDRESS, // Source chain address + INSERT_MOONBEAM_ADDRESS, // Destination chain address + { + evmSigner: INSERT_EVM_SIGNER, + polkadotSigner: INSERT_POLKADOT_SIGNER, + }, + ); + +const estimate = transferData.getEstimate(1); +console.log(estimate); +``` + +```js title="Response" +{ + key: 'dot', + originSymbol: 'DOT', + amount: 9979919679n, + decimals: 10, + symbol: 'DOT' +} +``` + +
+
+ +--- + +## Asset Utilities + +The `AssetAmount` class contains the following utility functions. + +### The From Asset Method + +
+
+ +`fromAsset()` - Creates an [`AssetAmount`](./interfaces.md#the-asset-amount-object) instance from an [`Asset`](./interfaces.md#the-asset-object) and some additional parameters. + +!!! note + To use the `fromAsset` method, you'll need to import it from the [xcm-types package](https://github.com/moonbeam-foundation/xcm-sdk/tree/main/packages/types){target=\_blank}. To install the xcm-types package, run the following: + + ```bash + npm i @moonbeam-network/xcm-types + ``` + +**Parameters** + +- `asset` ++"AssetAmount"++ [:material-link-variant:](./interfaces.md#the-asset-amount-object) - An `AssetAmount` instance to compare +- `params` ++"AssetAmountParams"++ - Additional parameters needed to create the `AssetAmount` instance. The `AssetAmountParams` are as follows: + - `amount` ++"bigint"++ - Identifies a particular amount of the asset (i.e., balance, minimum, maximum, etc.) + - `decimals` ++"number"++ - The number of decimals the asset has + - `symbol` ++"string"++ - The symbol of the asset + +**Returns** + +**Returns** + +- ++"AssetAmount"++ [:material-link-variant:](./interfaces.md#the-asset-amount-object) - The new `AssetAmount` instance + +
+
+ +```js title="Example Usage" +import { Asset, AssetAmount } from '@moonbeam-network/xcm-types'; + +const dot = new Asset({ + key: 'dot', + originSymbol: 'DOT', +}); +const zeroAmount = AssetAmount.fromAsset(dot, { + amount: 0n, + decimals: 10, +}); +``` + +```js title="Response" +{ + key: 'dot', + originSymbol: 'DOT', + amount: 0n, + decimals: 10, + symbol: 'DOT' +} +``` + +
+
+ +--- + +### The Is Same Method + +
+
+ +`isSame()` - Compares two instances of [`AssetAmount`](./interfaces.md#the-asset-amount-object) and checks whether they have the same `name`, `symbol`, and `decimals` properties. This method does not compare the `amount` properties. + +**Parameters** + +- `asset` ++"AssetAmount"++ [:material-link-variant:](./interfaces.md#the-asset-amount-object) - An `AssetAmount` instance to compare + +**Returns** + +- ++"boolean"++ - `true` if the `AssetAmount` instances are the same or `false` if they are different + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const transferData = await sdkInstance + .assets() + .asset('dot') + .source('polkadot') + .destination('moonbeam') + .accounts( + INSERT_POLKADOT_ADDRESS, // Source chain address + INSERT_MOONBEAM_ADDRESS, // Destination chain address + { + evmSigner: INSERT_EVM_SIGNER, + polkadotSigner: INSERT_POLKADOT_SIGNER, + }, + ); + +const isSame = transferData.max.isSame(transferData.min); +console.log(isSame); +``` + +```js title="Response" +true; +``` + +
+
+ +--- + +### The Is Equal Method + +
+
+ +`isEqual()` - Compares two instances of [`AssetAmount`](./interfaces.md#the-asset-amount-object) and checks whether they have all of the same properties. This compares the `name`, `symbol`, `decimals`, and `amount` properties. + +**Parameters** + +- `asset` ++"AssetAmount"++ [:material-link-variant:](./interfaces.md#the-asset-amount-object) - An `AssetAmount` instance to compare + +**Returns** + +- ++"boolean"++ - `true` if the `AssetAmount` instances are the same or `false` if they are different + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const transferData = await sdkInstance + .assets() + .asset('dot') + .source('polkadot') + .destination('moonbeam') + .accounts( + INSERT_POLKADOT_ADDRESS, // Source chain address + INSERT_MOONBEAM_ADDRESS, // Destination chain address + { + evmSigner: INSERT_EVM_SIGNER, + polkadotSigner: INSERT_POLKADOT_SIGNER, + }, + ); + +const isEqual = transferData.max.isEqual(transferData.min); +console.log(isEqual); +``` + +```js title="Response" +false; +``` + +
+
+ +--- + +### The Copy With Method + +
+
+ +`copyWith()` - Creates a new instance of [`AssetAmount`](./interfaces.md#the-asset-amount-object) with properties of the original instance and overrides properties that are passed as options. + +**Parameters** + +- `params` ++"Partial"++ - The properties to apply to the new `AssetAmount` instance. The `AssetAmountConstructorParams` are as follows: + - `amount` ++"bigint"++ - Identifies a particular amount of the asset (i.e., balance, minimum, maximum, etc.) + - `decimals` ++"number"++ - The number of decimals the asset has + - `symbol` ++"string"++ - The symbol of the asset + +**Returns** + +- ++"AssetAmount"++ [:material-link-variant:](./interfaces.md#the-asset-amount-object) - The new `AssetAmount` instance + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const transferData = await sdkInstance + .assets() + .asset('dot') + .source('polkadot') + .destination('moonbeam') + .accounts( + INSERT_POLKADOT_ADDRESS, // Source chain address + INSERT_MOONBEAM_ADDRESS, // Destination chain address + { + evmSigner: INSERT_EVM_SIGNER, + polkadotSigner: INSERT_POLKADOT_SIGNER, + }, + ); + +const estimate = transferData.getEstimate(1); +const estimateCopy = estimate.copyWith({ amount: 2 }); +console.log(estimateCopy); +``` + +```js title="Response" +{ + key: 'dot', + originSymbol: 'DOT', + amount: 2n, + decimals: 10, + symbol: 'DOT' +} +``` + +
+
+ +--- + +### The To Decimal Method + +
+
+ +`toDecimal()` - Converts an [`AssetAmount`](./interfaces.md#the-asset-amount-object) to a decimal. The number to convert to decimal format and the number of decimals the asset uses are pulled automatically from the `AssetAmount`. + +**Parameters** + +- `maxDecimal?` ++"number"++ - The maximum number of decimal places to use. the default is `6` +- `roundType?` ++"RoundingMode"++ - Accepts an index that dictates the [rounding method](https://mikemcl.github.io/big.js/#rm){target=\_blank} to use based on the `RoundingMode` enum: + + ```js + enum RoundingMode { + RoundDown = 0, + RoundHalfUp = 1, + RoundHalfEven = 2, + RoundUp = 3 + } + ``` + +**Returns** + +- ++"string"++ - The given amount in decimal format + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const transferData = await sdkInstance + .assets() + .asset('dot') + .source('polkadot') + .destination('moonbeam') + .accounts( + INSERT_POLKADOT_ADDRESS, // Source chain address + INSERT_MOONBEAM_ADDRESS, // Destination chain address + { + evmSigner: INSERT_EVM_SIGNER, + polkadotSigner: INSERT_POLKADOT_SIGNER, + }, + ); + +const estimate = transferData.getEstimate(1); +const estimateAmount = estimate.toDecimal(); +console.log(estimateAmount); +``` + +```js title="Response" +0.997992; +``` + +
+
+ +--- + +### The To Big Number Method + +
+
+ +`toBig()` - Converts an [`AssetAmount`](./interfaces.md#the-asset-amount-object) to a big number. + +**Parameters** + +None. + +**Returns** + +- ++"Big"++ - The given amount in big number format + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const transferData = await sdkInstance + .assets() + .asset('dot') + .source('polkadot') + .destination('moonbeam') + .accounts( + INSERT_POLKADOT_ADDRESS, // Source chain address + INSERT_MOONBEAM_ADDRESS, // Destination chain address + { + evmSigner: INSERT_EVM_SIGNER, + polkadotSigner: INSERT_POLKADOT_SIGNER, + }, + ); + +const fee = transferData.destination.fee.toBig(); +console.log(fee); +``` + +```js title="Response" +20080321; +``` + +
+
+ +--- + +### The To Big Decimal Method + +
+
+ +`toBigDecimal()` - Converts an [`AssetAmount`](./interfaces.md#the-asset-amount-object) to a decimal and then to a big number. The number to convert to decimal format and the number of decimals the asset uses are pulled automatically from the `AssetAmount`. + +**Parameters** + +- `maxDecimal?` ++"number"++ - The maximum number of decimal places to use. the default is `6` +- `roundType?` ++"RoundingMode"++ - Accepts an index that dictates the [rounding method](https://mikemcl.github.io/big.js/#rm){target=\_blank} to use based on the `RoundingMode` enum: + + ```js + enum RoundingMode { + RoundDown = 0, + RoundHalfUp = 1, + RoundHalfEven = 2, + RoundUp = 3 + } + ``` + +**Returns** + +- ++"Big"++ - The given amount in big number decimal format + +
+
+ +```js title="Example Usage" +import { Sdk } from '@moonbeam-network/xcm-sdk'; + +const sdkInstance = Sdk(); +const transferData = await sdkInstance + .assets() + .asset('dot') + .source('polkadot') + .destination('moonbeam') + .accounts( + INSERT_POLKADOT_ADDRESS, // Source chain address + INSERT_MOONBEAM_ADDRESS, // Destination chain address + { + evmSigner: INSERT_EVM_SIGNER, + polkadotSigner: INSERT_POLKADOT_SIGNER, + }, + ); + +const fee = transferData.destination.fee.toBigDecimal(); +console.log(fee); +``` + +```js title="Response" +0.002008; +``` + +
+
diff --git a/mkdocs/material-overrides/assets/images/code.svg b/mkdocs/material-overrides/assets/images/code.svg new file mode 100644 index 00000000..09cee987 --- /dev/null +++ b/mkdocs/material-overrides/assets/images/code.svg @@ -0,0 +1,56 @@ + + diff --git a/mkdocs/material-overrides/assets/images/code.webp b/mkdocs/material-overrides/assets/images/code.webp new file mode 100644 index 0000000000000000000000000000000000000000..717c50bf680703f48b1c77df808634b00e3563db GIT binary patch literal 3400 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 + diff --git a/mkdocs/material-overrides/assets/images/contribute.webp b/mkdocs/material-overrides/assets/images/contribute.webp new file mode 100644 index 0000000000000000000000000000000000000000..d580121683ed42bbeadb18aa464b040694c04745 GIT binary patch literal 1850 zcmbV~X*Ao30>xvW>O!VsNohNlQd=!e(NU?jRr}ItEj4OO>E9ad)S5C{1hMY~Phw44 zN(@m;iy~qPu`gq&*bNb(2CwhK`!rwPdB1Z%+;czObI-LkH8If;0D&Bg4XhE?+U9cK z{S69QRTwMKNCqAw{IClkqlB zvqojHP?fBYjD|Qz|2lGGa^G^ zc`$ESe4?>1FP9Wv`VA?-Hh~xXrdYVMORcm*+E~FlTH#vkur}X4uqIecMAW#ro*VrP z%*9t&YVhg3g4jQ)I}r<-WWmv39J$H@W<3>1o~7-sEY**))G9 zV2KVz@16(!le_G^&&#Q@rfL7XF!DD)^8dwlEO8J^m+eh~kCF;*B;ALqy$OS2Q*R~i zKk>tR4JQPC6yl7WqeUQ*Z{zh)jh}zKQiuGajgP+#76tzwNZ|A|x&B!{D)@x#t!ndi zO-V_d*vWD?B}oSO{}fZGMfjy_5<+_jINJBdJcu1+dvfN6VdI)(QV(dJfYY-Df~SNsU;KGnvK!-YVDky3LyG0VsJ zWj!N^xN?E)Sh6oY;e$t@oSf7nNWiVYciXqH6n2kOgh1o3gvfx-1c_ zvMqJgwp$XHSJL4B)nw=+_u_%pWf9N5Fy-3(wj z+pl6gU~Sb?#Uhnf!WjJIR!FUG=KE!i{iOy)cH1$%qTOg|oKd@shA^+y93F>D%k!Gb z%q>j(D&}HVeanBY<)m?YOvG6WiR(nI=4Z72u+zG{nsIaNZPjUdR#WNINBr_h?9{dS z&L~yV8ESi3tsdeydxGfpZ1LL`u2WTz8e{4nQT5I2h8@jbmR;Y=7Wr~w`R#+X7Qa{i?NsKRmnJjOasd%`*i2wcQKS;T{NSbD*`?(h+Nu?qEhHAbvY|F}g+DwGAYbE)YL zXV_;~sJp5&@IL+779qJ%mYkgnsXKhw-r;+!#>n*PXIg}0LRmU?F2wHeu}3~um6aqL zcRiqLeKf}^cP$jQoK9%ANjm(k($Cgi&#x+Ie$@ayvg?-Zkx{+Lb}4}aiW8^!fdzuPY+fn1cLVO=5_33 z&KwoJTA|O3)8)(Vw0Rr+IP)sV#l)gex4w|VTB2XI5ZH-m&~oJr^b&E+58M)PRz}Ys z9ZosV;}T~8R&4Ea>Hh9DobuwDQs4(m#B{``=;cryAGiY_C9KP1+HNISil_`Vto2vw7VfzM^7dDReSW5<>2x`}L;l1?uA_Gs;p3!pr zj@#4ry~WH3q~F^kR&coOYl+6k_!jf7DW?T>_()ICXW(~OUoKA=bTc~KVskd?;UsPK Wz&?X;G5W+Ry8ja5LvuNn3-oUg>VpIT literal 0 HcmV?d00001 diff --git a/mkdocs/material-overrides/assets/images/learn.svg b/mkdocs/material-overrides/assets/images/learn.svg new file mode 100644 index 00000000..df10b785 --- /dev/null +++ b/mkdocs/material-overrides/assets/images/learn.svg @@ -0,0 +1,52 @@ + + diff --git a/mkdocs/material-overrides/assets/images/learn.webp b/mkdocs/material-overrides/assets/images/learn.webp new file mode 100644 index 0000000000000000000000000000000000000000..9e9b45e26fc156327ba592b10a22f975a65d808d GIT binary patch literal 2176 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 esl3wB-_QpZGxT>MI literal 0 HcmV?d00001 diff --git a/mkdocs/material-overrides/assets/images/moonbeam-foundation-dark.webp b/mkdocs/material-overrides/assets/images/moonbeam-foundation-dark.webp new file mode 100644 index 0000000000000000000000000000000000000000..5979d83d378d1ea3975237d8c2184504f1b3042f GIT binary patch literal 93794 zcmeFYRd5|akS%Ci7Be%0#f%m+Gcz+YOP0mV%xp0;Gc)5AUokV?)yza}Z0yH;Y|O@c zAFraKt3NujvNN+zoy_W1k`xouvitr`T~tUxO@UKJ?(3f6-^?@;=of~}5d*%^)%y(S zCz(qYkm@JWH*i^zpX!(e<&dACWa+WyE9((Ue7BK$?q<3)=XH%#?JlHRJsWLC$hu(y z+ymB-xJC%v+F^+O#X1RVIi9))mvf>OYqLi@@0upR9zX<5)Nv2^YO`*O?Y55?610Gm z$e*50r-`;HFc7GmoqXeo*Zi2i4y+dHE^mkcR`e#JZ>L{K?DR*UG}EzyR%m^)7-IkQ ze!&JtM@I*^*^w7M&@;>X;>!NR574x1h&1Pq*l25+u(7<3Qv{9#@A2(8w{mne3>C;A z=h54Ik)CY=iXpq7w!Vr0KkwvobF`TVA*vx?Mt-Zu-Iyq>p;A#E{`u6?X|8DKikouZOX%D8izK7>WUI^qc zd)FdQRdMm*+wxcY@`IP4^@#rNT}n#I5l6-_2ZDX;&FgxDm)lwUL;J-4e(&?Yn|=R} zKL5u8|G!zF8Jix4w#PEHaJsT%KR$e+=ULXes%cs4zq?#=x-<4P6~BzdbL0Zf@-CKj z&TES0VQK4^?ZltDs&1NQJ{SLA0_bNj-p$t+gljlGL3AlE)s;ctG&-2IyX!AXABbSognln%X%TA71qToUi>H!ASXpJ&1f_ z^Tna~sQkaR&hZ~ll?9V#tN3KQF<$w7kN~+|!T72h6zaFldVPS80n%qi{iE~L42l03 zMY>$&eH8+)zk0tkmC51nzECn_vwHpLYOk~4`@HqEQL*`pt*sCL^641Z>9y7VWWQQ# zxuBTIVgI>YBAdH;9q)Rk2kQUDcc5?I{swAre(ToWYOQJfF9Ysvx?VOaHf^cB0I2QT zI`FP*fn68U{Gb8Kz79aLKUW)QY=!qQ54VPPe`O%Y-RB?@u<*9TC|X!QG5veDgRq*= zKlbc{p96H>pPB10a@J$@U$!FmKJFnn=>a%_Dh}|U*kgSMfc|bV2k_Ss{C=Q92H#oN z@rUV;><;_4aYvw}9%5?F?Gz%<6QB2oKdZlOa7Mdh8@G|rc9W?}F18IEt7`)pvSQ z_H*4wc(SwZ_9>~_7Wn0JJ;uS%zcOI=zu=Dd=73Q{ncYo%e#dK{R2a#tktI&XYQhJ(YWOY$j zpbw$1zI~31=({5NJxOZY^g!y>zo54;uxO?c-qi(L=E|~z+r6*9%YvS!_1^%vRkE;6 zvd;hM4Bp$~9$!$tbLbr%kXm=eRkx+~f2>`9R{EwQFg@#LAii-sM83#kzIY(MpA9d) zB`v*;`dPE0F%ypp%xKkBged zEB}d!+=o^`=f}g0%trLFmoMPyf2Q-}A%qU>I&l6k9QcD?j6VqHQ$fN;zBAo5eYu|; zW*101We`2mvFUDh=o)WE#bVWq3l3}FZDI(Abtd-TYBV!HUMjvG5Fh06co|p*ZO>~P zM6~U{if`t}Z3{nYeT+HlbP>>hzTOFan&w&_kL>;t=vih^@--#20)b@D7V3LIb0c~; zVcfbbvWOWR+PeQ;WAnevY|M`w=#=(ozPEmB(f~9NTGg3vm1p5YybtcUpIDN+={3n+ zLH67M-tIuY`&^jkguNa-dbx28EVa^fD7DwDkX4|Li5Hrct!j^L0XJTk!ih2odCd;} zPOR4qdwTu9Ql1~7gx;SY)!vhrFtI59w)R*w82Z}I*xX31Cu)&sE3`ww?ML7Ro#Lp3 zIj?oXrB~h8(Mf=!Kl1dnC|9{J8@DY2xxfO*q)A5bP`gfzcc-{hSD*6?T(h^XeLzI) zV0eDhvgm9zGyucjQ9s?AFTKte= zcNGoGj3{>E@*Y_t+G3dg2Zfd&$MqQAy?ysWT_Ad@_=)o^dGz%X1++^+-K#v4PSvK5 zhhyjWZL{pYW^|nJNA{_zQAg{nl@uJyE+fD9yasn(kHGhew_XLNmpw0;VT9v}Y`U`& z%c>@~PdhqJDt1C{k2PIXzqG2WIhtxF$)v8RBX;Zzm4QEtF1VK(NLM)AHQRU+z#5k2 zEiwrkUkpHJCA3e~%$_hrH-|D+be*_&Bzdeu_;#Z3KzPhJ$*#6>zKXbD$}Vnkx?M0hSL;v85mR z>F2IbQO5Or*m5vGg&<%51I2z=O5{qHb{SnwB8a@qGLt2HDf2$zbfDpx?o7PROVqub zdU=%~z+U=C%Z?xA&SdJR-=z+=#XMdsyYoI@$@oTY8zo(DyCHsfuDkQ=H?-TgdoKg% z-Eu*?8a1K*l|7m+8rCsg#=8kQ5F)86nOLDwb+hOfEi^{M^XD1qzZsv?6eCLbeN?k$ z!Sb&@!UvE`A=^aL+&5gixUeRc9 zvAI6B9#2<&>n{Bw2+FTPp>oze#p^64ithmCa&A?n{v&#E zLVVc{s}Z$9wvIfz6JNw%hK@m-J+0Yw$m=={5_cXOLu^ur9;O`{qK|MF|Nxo8`q(hbs%pe;dIUT zVdmfzyAJx<*)A}2n9Q%X4{$dSZCZ*pvR=${U&t8IJ<#MmuUN^lrl zRGO{+vy*&16ef?CKXT>nKcJV6U{?+j+IkOJ_`G^L!;u}I0egJo0Eg`NrVt%RK85qL*f>-gL+v)!)3C7>Q4MAP_5|y9Zrypr>R$R}`h5bd3VhyBS4S0eZ{nN&0 zeB|QS3k|K0NGw^?Viu~w=t<&SYD?xbuKOAUHjp!;i2_T1m(@kh&1`2579SFrqd5(y zd%gAi)KU${_)ZX5;mjg^pz0Q0torm?(T@r4<7ZkTqhCAs28;(!??IT}dKTi>Q=~n( zE?Y*lBci)WKiW_NZRQ5Y>N&TakGASo+GxzA6d=jZ5jz^R{LwS(=C!V_lO{`{^>W16 z_VstI!PD*3O9fB#C2*Y(fcU}g#nz}XTIiC-z$K?q@5Sf@oV=^s9Bsw_;aA{NSr^sf z>JP}H^s6e(Wvz7B{Pvrrr29=3qHUq3v-@l*mLZw>nMp{dZCzD(X89(O#>_G2vw$P+bnrALEYWGg=-eVjBrgul|2 z2i)&si{~`c1OlxD9zn8vs6n^8810Hxq2qJtGPTJd}qgen~=tWEd8gj z-QR?f>^<45*q#~sXy$o#Svn*yFm!Ohtw-B;w`DC2vnI`lP{B?RhM&w_*+1i>CSK z*{97np670@6TzJpT1_(4v6yE2aR6AKP6V0`CMF`|Xa6K^TCnNb&F;97jkGcMeMVa^ zPzjk(^tD6GF%h@o6v!mNAON8oQS5l}0JW}F_U>Q!+Mg6zZJEPNh@15k<8Aj%^w^y# z=Ct~;r%A+Rxr?c|h~_z_PF^{g;9(c)YgG-z`))xJqk4Y2Yfcw^e#UWkIWj)hIUdor zJQHenV>}3jFRfvSOfk^F2LqL$R&UPX#_r+@sSuxOXHBJ(GtUTOs%ZO9VHKHgbiBgqeJU)JRV6Cqh)v zQ$~JbH5t_ri2EqtfI`Ez`v-OMKDN`mLZ1jgM0}awckGB4{?)88`sg`@%+9H@$>V>U z{62kn{4)=$4?4gDm|lcybO}sel-Z&@d*&GKN%sbxC(e6iMq6#O@LnM*RSw7Hi21U& zTtnfD_a--h`o?%Quhfgp=tL2}t`V-#Pk{R){jW&Orvy>joI{VPw}BfLtt>hZu0dq= z;l<)=Y}u1M_A^0I8}v8OOrGQe!8=0U@vYVf*iu93E&NR}%DYzGC@Y!Ss^4c9V(s)$ zwumZ6h^B%MKro4bEy&9{$w_bRok_80PgFtr(uc||6aoN^Bv`&HcCzG2^&qZ8C^SJ(_SW9U_# z_?JhCVAztF^~~46AfDAU;N6dQy|F10ALyluo?wHsCcD^kdj3sUvrn&c)N>lHkGRX}pT+-44# z^EwSVpXbih-1koV4`IA(JOqIvRP~1QHn1NJ{^KhxE4whuM_vXC*4~59KXJX2!C(B0 z9;WjrI^g`v2+{D5_XMZwLf~m%hT+JUx+g2k*+nQ(&9}D?aqc*I5Tj)^ z1vf|o037Z5Am^}@*p)Z(PDA@A-Z`~ph zw9G=43`+TYiZ8jPdrTQu=8YSBpl*%N$!NDSnR$l zpQ3`(-rw4%@(!VGx0`51lm)MU^}goSK!J!{jU7f^+b=qqB_+kCqGR=49Si{JEliQ| zUMaqvx-1t!-;&6t_+TkLmjRfJtCTxV^HmVDUk&Bxt7@=0qUPts{mQFppCQ0&+*^cU z|B>H_>>N#F=M(bJ&TnE)M*{`2FK5IBHm6U^pgWgO5YvFX#^qyP4?#&&#W#nHsrW8kZ~XNEw`>sH=E^SbXIuftgB4Bb}znH zAObijDN)R~{pP=SLyYk*EcIO z^4l+J_g~l$Y*Tr)Tg_W|J=yV9|z=}IR zR_8acPZ!{>0DL%OqAq_B5lz(aUrJ#ndi&gvKUsKM7Rh=?g5|u%qw0>fz2zrY*8+y_ z%nk*Pauq)IG(N(p!^kIbp$!1D4%bTFg4fJ;m>3;h#Z6|7-~~T&a@@`p@n2+9iTeN9%Dkd)bjhCW+d}?u`-=CMj@3hg>%!uV zp=Hw7E<0A&pws2Lk1%?EzO;1roQ|Q^*8R*QdlPX`berokDdN)^w|CzNpAM@6- z!r;Hb41VFXOF$~1nw1CY5Er*%x76O(f3%c=k>^2<=r_V*2xxLff4eoXx%=TGF}8iO zwk*Q^F(5H^4m0J)B}Cn$mvnnyAj9h%sLht|0$iA?ba?;9gNGn?w$i_cz(s=T%C4gr{4+SSS) zB8}!!4@EVgo(VZ#2HdP94{R~H&Gwys8$)l1kVyCQ)}^b@6>H{inR3MlqULDGJoP;v zWDns3=`Hb_=B@#;j=T)))Me5gtHZSm#NJF;f1+W~Yt50?RqUBg#s9%i+0S9F?v7S>Sdb}WgSnMJ%1qnd%R=>ul!pV1UAMj2XG4A~g^~Hzp_Y>@1fYcm4nX1RM z!vZ*L1LwPjN_nz8y^ZKO9ZVW5H#sYrHt!3y%$-waaxV$`--Xn%;b*S5-bEn91Bu6N z22B7krD;CjH@nWEXln*|`Q7U{(&uUzS=;*1(8FxC&$$?Ve$LEA{4?F;TY%)k>ZA`k z2}dM_8q=IdEn>0Pg{E+prDz>sW|7d~KHu`d)DQXY)xW9~fDz5HZAXc~v5&67dNAFA zGum(P2DmTaPiIZ527A{S^)j79)=rbNuNL~SV;ap=g|iV=7SwruE+91713#H>g<5$Q zvXd6In%4?_J-Xq#9C#|1MG998{7k8I{tLze$~K<0I65oU8*+Bu@Yq+ycr)xs)dMjH zF3bIUay|atJ%z!WbqT+4i9yT%19S`cBvq&TU0r}i{I&Q~i`X>?35PGXFz;z@QRTw) z>Z+AOv2zCxq8W5G-DSA%*pC7O@=?#ZcMn~>g`4=@IZAOfI-dw1E3ex7+ddgmS5X!B znJTi{{mz}$*WV;vA_WOkE_9v9dRs$trpvpnHE!dET4)J<(cEESe|d$Tqcuit+zjN4 zTZZy!1bRC&bnY%7{*$xhylZxjMxC7TbotvAhNyGM6-Ca#%Apf;<*@Y9!P{f?j9@Hj zZJf?G1WkXSM#-g=S2Da0+K!d-QYT3AS)0;cP8=94uPYJu6XZL}c;4}!W@}ve8|kdO z%O+CFn&sKi2fGYN>9Ln}>N{jYJAFZBsBe2_5XBY*aQqo*&7xR-Y$k zg=KqMdp};^bsF%Z6h=RE5r~sJe4C!d0R>d$h6sPK&vGxPojIpyPLF~JSFK#ydJuIe zbCey5gfhGN?+RuwslXCQf7)yItIK#`r3QM%#+hzD2F+@{pBWUgsoDE{NJS`PeNnLU z47_VCZR)ew0cgfBPfvCo+i~F$NH2WX-G*kDT1|Y>R#8IRGo{4`nf=p&JH-u(N!2R= z9j@~lv=J^gmw!`f>#o1HipNUA)=pZr3Y}Y}2JYlsY%S@QLFs(0V7xfiSI}!};fhS0r?VI!Bk5wf- z6hG2l-eXhH0xf@&wLTaw(yq-~+oXSJ(6%vxIHU{as$4?Xde`aMm6#JD`J&z(WBW#F z!5%W6(j*jGPaM22JcfKW_CnG`QJLdfWL2sU{UmHVzox-^7z9Us$SLi28a~gqw+MTA z8)2~%{E!z;z^`)hNODci|7O>2%cJ`f&@-fvsXV}G9pe_ML`pSd-*eQ@0+BTMf>n+> ztn$cwZm-b#WiIz+8s>gVG|b6FA4NW{?t!d3c5gUo$V`Gho0Rdrrlq^Kl^<}bBG*t=D4bNMOjTlRVKmwVack7ZHtE6S?mjKDao*? zFVc6f$+?wdw)m#8;FIusc!xJ$h8-yiZ5dPiEvCrLhVi-sH9LJB_$p^5qJ)aCw$FDO z-Z-rU4_*_?v#LH#HQ}@%qSK87GR@_OFT}CM6TVBURfW$*R(8H1f*1yZP|@~FA>J-L z()-O7n9oDX+pw8TM-qNQvZGIgRH^yhZ2V>^txBJJ(h?7fwa0d1&%_q(zsU&WV;3rgef%5wrtthqx!8+?hEO1Y)CbRl9W@ z;~awa!0aCnzR!WzWRRRNnx^4nJyFxJC;&KHIe&asptJOz?@Hadveex-o7)Ub@PU+Q z1hLvke$pQNG9upB)hVt6gH*x|^3ie)JWJUxT1ZMK=O;6PEQ1k77opj2?kB@${@X+% zoJI=)-5yRU65o{kAP7$q*MEj4>ODg~ z>T2ZCgXYN3EjBrXgoBcKe!=o6gBzg1Am|RUlxxqn&qjqw7w?&)vSZ@0L~T%{@P&L0{_{83R3tt8Mv8|hUfSqNM}s>V2{ANGbn8nw}l zO>A>SVA7jD@o}OC@E2=X?0r{dq~^k;!Z6Vj&{CZVkbyvF($Yg32s;NOicF66>jk9< zG+8L&%Z0BHCv6E7HEH%~*RjMrO9mH97$#;{*H%>HX`2#$$Ob*ngJ$GczV=DJxFBwe zqMPnJiN2Nlm}TVeeiQhAG9rp`=}8|4Z@|F#;#kbLV|q#=#8iZ2#(|3>(bz+j%#uaO za3bBaW8tHXqNIZ(4nyjhaj@bCJ;*%)CMNw|92oJI9#8C+R;XxLmR1_pwgwryBjTn6 zHrgc>7yKr5lgWr=V^-#MoI_YS{_0FZ`a}xoI*thRs{0>$1AlL}?7~^>!Qf*If~5|H zXs3s7z)*4MV^BHymx&>9xkgkOKe|H|<3cdn1uM0&ZREH=ri5Uty@&b;%xSz4bSgR} z5@{#=t#|+~%*GlvWsxe%+SM9-nExh;#9s`uK9dtBe@7{&r1`@XoUY=(Q;xyl_NjQF zcKCRQ{EYkpNfot)1Q~weBjHzGy=f24%nKPat zT+XUSiAggS5^cjHFir0X+*=jym|6TT_b6Byh;k6`gMu z_745UHy~<*GQ1Y~+*a#sbbWK0wVy2nEYdlP<`PL9D_C`+y0w)p-1J9U91XzhxJ7apSelj%Prit`#gvncn zYk%{Tuvs~X^&Bg9l}37?m1=){yqa#C12ar1^Xx{jn?%1nOrC)|Y!F6;l2~#!cL#`% z(5bWgg-t?!RZ6Og`mL*F5@RwTOP8H8hdkQ{oGxZQhAm# zbf(&a)U>;zuf18X=%i&*YhOdp)iFyb2xBb2yiTU1tfN(DOhmNfPNtR&YFHcHk_YWT z`j%64@X0ia;3B04Ph1;s>rDj>g^8B?t4Lok?N&ECeJPu4ES03tb#33pLDMko!8WGS_5&oh4uGtpXj zt2&Ijuv>tZh_*r!YN(&?XX*K{?L>rTL?so4ijTwn%bjz9j%z1wa4+-6R0)(KkUnf}5%$wyaio@?N4%9MCRF&5?XlBBW%f~H% z`^g(*%zi56u)7o2zN^?))DODZ!q&e)(O@JL!f_$2mXDupV|SgI&Z)#fr?~!BHp$bj zHrZT8S)UcbZ~lYP!ZC@%ak})V+MBObjH6w0RBYT3&LPvf!Eqo;@tV7^0pDj@mLBP9MLQ&kRZ)edbkFF@fi9Zhe!Qe-VqGM+?19DkDuJs6B7S@^IjKpH%Kg}7T(KL7T2 z189PBaI%f80O#Kp=w0G*DRw$p2bV}H?&4coY+Mb;nsP3ie@fLfU^C`!T1`Fv1C?o% zLOQi{b~^~Iq)G{Ou|}UQ>nAGM6x%qjyQaZrUMr zToL@}X`4YV1EF>cNi+PA)G+tIE@;W9i8f#tr#6urQ;}1cv6uvgL}qw+x>VdsQMn8w zasDZdcg_4XEd0{ke!?5A9n6?5KI@(vi9_r@S?rZ*wbKz&owe4U<{38lsWeM%Yx!vs z>sDbMtFzW|;3Sn22+6)PneULJRs;$NX;=iJ#D)GYOXJ6qFozBYgQ+1 zS$-U&{RVAqb18GT$gt=J8^DZNr*eKa(lO&P8X7Pu|Mm#xw5Ma<5jErsf@3`CmKj2- z<{qTje@y;?oy8(}DZk^Eh#z}0rBgn`T|S*8^oQ8($W|cWtO5x_C>EQv+k$jh)f_Tr z^{1tdS|6+_JM+d+l9K%A>6?L1B9{({>>e~w29rxi>vy13cq1<>c1WgZKp1s`Fde#6 zUG4|AJIR!E|IXTM0?9zhVLP-MuJz)`ZDQpt8q>9zm0(IFho)(KP zxg!@RmgCo z%ZLo9S-1N_C+KJdC7*s93E!Zs^mH4ZOI2_vs%LbRp?jq`d0g`=!{zP#Pqv>4pjN%v zy5>Lz7Fj!(#a=k_-YG!H5TX{vsYlt*3Z1ka0_7w42rarxifir>9)2xS>r_kuG>^UU zc#|~g2g}`V7ScVVos?p#ulULNY_OgkmW)fIzC9B+^?lW$9X`FP0)Wh~e9)3?vTSI< zYzMn%+4rq4>S@#N29l}EGu<%J7~MQWOj?oiZh73ZnMAq^&cMXVrmPQhX+U5&rFL;X z&s7~%Dvz7?PF?Ju`#3#uW*DM{H-E6|I#nrkNf`~uwdL=&Zuv=9FA)<_pIK?pT4iHZ z&9BRfE;7?dZxhjJsyXjXLVM>*X|jm`MlHOu-o>C~W6w7!rw29NsP!lRi$s}(Oa42) zviN50mW0My5k_%-S9yX{frfZ>bX3Hwh~>}vOHpsjz^jOm5}jsyh^1i=ms>s~&UPs3 z?WCah6%@JG%MUF3S`ka%8lyZ!|!XSE)Ae%QUk5FsIA^=!_hxuDNLQa*tvZQxzB#maj!-^tS7jx z^mQ5CuT|GOKG!Ia$#^Bxjr~ElomTC*kAw;Mm`{yzsTJki2@M}44zDzxPibJiNOxIOKYgXdA(<4AUfWzj9x%rGAlm{ z6sO7Z#8v0YP-88)oi6%I;`Sq!g?}M9mySme0MKAo(93xQob1086=^DH=G2F?1bv$ zVP*LoN+R}e87+^uyqEEXR2d}Dk~7(C7QiCe7>9+#Svi;OaTwtWwQ2sT>p6Eh|55)2 zNM8Ai8{PEWs$f%+N&xeQV(RK}@!i^)S*M9>-wi@{((RxIo>|Tulq~Rq ztJLZRxZYe7i+Gb zas*nuZbX#=uGU)D{`w$r#&2 zPF&M;rNW9t&%n876qPY2QXrTPS1%t)wr6Vw<|F;15fqCZQgR3GQ^-o375otxAj8I-s9kY@(P)qWE>OTJfwC@xh9K%_Ovx1 zq6&9mX~AV(G0+G%EVIURk@g%^JQdq-w4?tJph)4;dh%TxqKRf9lRqMyw`E~p#~85_ zD{By<2jGB+7U1)Xu?bwG{e{eje+>cA+ogt7y!+8FJUWHs%OUkWWRw(TFTQ(grj^`A|eZ-u&*Amzt&GUYpb9s7i8ygBnNi z#XMaW=z7U4gU`NL#~pTPl+O2O1trqB)Em%vAA^~jKhZp{)mZH!C0w{GF#+dw6UUmU zy4vN=)cM?5iR(>rLXQ4g5j-6Q`{)nL@qG)Y+_msu7>w9;jr0DKp3z%lncBb6t;CKj z^-M{e2&^PNS~!wAeG@Zs*zErF7UXE!3aq42s9UpuUt@#xlV&8{^v-`0> zPvvG3+6iZ&Ilj1}a+VU%8#?4vqc9wxS3=G*&DBu0vKApQ|G_EEZquTiu`VvZhJN*G zD!fD`TReW1Qu`i6+xX=JbobQ(pOCX&(AfSrbaCT#{TFlAK9 z^}IP$u#AF{SDtlipMvUz?LPC1o##qyz=@E-p-t(gO2SM)l#0(&B`62OSf6@x=PTjj z>A@4TJdV@*RR8)U1RSV)Ad;alMGlSLvP4VYfT!jaOB&K*uo5|OZxNjCxupHI!FfbM zR5PMQpf9>7o8&h<*0g=>dNm|Ag&4G77@FL6gX7{3Q2&3KS-VL4{zj7LRjWmZZj=*I8>`~mxCD6 zlNd{WVaWeqwf)v2d9-WGI*IIPa{{sa>w`W!*}A9Gzuoqef065Payyf>e|jT6B|AhG zPQ-2!n1t2*5-A+u$8euQQCQLA+=OKDsu&syAGC>|G+7_*zA_c&z;+C@3YAUgHcHuc zLO)Z@NJvp<)NHK1`Uv;bA@{Cyt@80f7YE6S9ZWU+%VhSL^FCWM93P>A>|ded?+sZ+ zkZE#)#l7jeN_psQVklGGv0u2);<5ZkA_vjD^osu2#3Pd6c`(@i{Y|G8Z0@^fIzH$# zBL82f|BJc58P)p$(hr7|tvrO+5$UZ1L3Z>SwH5R}3s_4UKMQs~pdV?4u?2x8pX4g| zJaeGl`g0vi%^C^Q98##FEv-dfTFJtqWBb=RcIKMeH{~z>YVns;V>dyOg;UK}42!(3 zo%DO7oiZTkF0kd-7?e5&#tCO0Jv@Xp;!1i8i*^9jde55BYCU&`R3LID6&eGRwcc1r zU|dCrsqfj|8S#KDt;tdHy@d4J^7wEEH5STBTlyLdhFZ`LoG*FBcgS#|4XspTfa5}* ze<4W&g7HhG3Mbblf?q>b!V@HRX9=Je#VQleX5+b#DxrVaU~uqbZ(cxY!NFL_`lyu} zCV0yx-+Ha8e!`1DUAUW~JahD57NyLyy1mZY5FQZ4r8uSH3OB{g@)J@MV;H^M{SS8v ztR-$XkbjCV#j0=xNl@MWIZ>6tK~)4JNH#F%VuZ314O9ABfjX+k6tcxj>wPa^)>w!F z4JKS96OeBY+(~R^4dd@{$oAxREEsg~}uOpzN8 zNU=8gxBX`xVkQLXPdy5SsWIpDU<(Ht8RGqB;;eC+x5R5|o%SJEiV|zX;;{}t3T*1` zbkFd90#i#A+19yo4G!rHv0!rPDPpTN{GEt=w8>eP9+f3HN`A4R8D;!N$;Homou$*t zqgb`X4cU$bVyqC4C*~0^GPwpoo49HL^kWv-eAS=|b3ox!1P&^G6;CLkGFajdst{}T zAbDRcTWjaFNJUL)>cdt-w~8m5BvbGzTG^0CsLk}2NaVlNvw3shEg`DVKWN;>J+wB; zrd81*Fmx&DMTgoxIVgh;Zp91Q|K%&-JL5+2H{;$iWgZkX8jbsK$E)1_Qf;aHXSsJH z9_+m?oa(rNLhp^`OUyM;2~T@eg=$JEk)%>`#C}%*C0%$v_aEsTXXRUsg@`HiA&uA) z821_S84>fJ=FH{~<LxT-qBqklr)evKH)@) z^gFAO(~)gClPQ|>%$qqC1ghxc#TwOFzlE13M|F2Hu zhAScT@~`0#q^a1Wv?W&w;eYHS7C4feyI#rfiPo<9l+&Rp4i=R^DCjk#N`MhadyaP3CUuqJ>=7!@P&A?utKX$5TBIVE|yLp?jb0I6W|GwB|!t0b|@EU zE1jg2r-M}VgDypqw^4TBF)GQ>Y$SIdjks|gi@E~6Bs^3|MHU^EqoJx3-@*)^J zXiB$8g=x*8VR42xj(SYX2tu<@6E8^qo-5nCLaHI7?>`bbv>ZHzMNv^@s0yN%)2H;6 zDR+!aDtkz(w%Z^L(*V{5UglDL#%@=MV5~r07Lg3r@{HS1vS~M z-Cta-+Gt}tMA>6?gE)Gxgm|HXEJp`hlLnn?U{7}II&ewFez=l_&5HJle!${*zSDgi zvQTKJh=kbGnaCQ`TEDO$^H*qjk(1Tx_)3=D5BczPGjxE$uJj5e*`e|vNi0?8*zham z-GGcaQiTb+tc*w`k9B^aT%#$!AjeWt2)(f~=N)^P6DwVqzPL72DjfV2aTMKJpiy-{ zd_j?+tZi%(O~c*F$NiR?#r#$DvM~}!RLg9(rR=#od)QPlekxHoI#!u8J__-7so;oA z1CAB8v!R$4T#WA!x7@eZjfSfA8fPdxl6xOsiO*gCjJ>+Y8WJk_3f2melS1RPl&@o@ zag27=M}fxsesqB!t?3g-O^~zRn%-!~m zmpfkY7n%C;R;F+|r$>cgb+bi4Li5K}Z39*;S&$m8u&neBBe@8VOYst^369qyOZz(S z(k6UugoasDFsPjImyUsWlE_)O(`>O5qs=K*Y2iZhDgpL;VBZ@_^Wy-*bZS2((llW zk)|GUKwh&e;gpdchRmirE-=>$^P$vI5UVBYrYs0t!>ZnUw(D+fi3%z{cqjwn>K6_U zK~ac}oJcCW?}xI>YQiF(Q=_@DgfPpW{dD>bC|Jy*XEs&^*#T~~j627&BYVk4GyXw4 zi7_iT{wpG+_CET`<7Go5N8qVr;-kTG{jzeyCnME0+87No)`O4CVM_JH80&gStWf?A z1Pv6g^>5>-Lgcmzv^mzKmBkLLA&9i1<6w<2KHP{f>Kuua0kN&{YYJeF%IvJt; zI6uV!x58Ph2vLj3x4_`pwdo-+69+aMKuzNN#v2XS!WIj%Yv2`KS|`#>Kp-_3`v@R6 zl>c2VT=b0mZIodJMrhjiE6WttGa%1=*?|>eRK7kY+<(;_zbis!R@h#JczT$A3vngR32p+VZAT3b>w=Cp{}ocj} z&kYk&T2gGGnm72*G7={?Jb!H}5G~<`KEx5HXGbB{$Fthu&`*(mYAGth!*x@jPM8rh z26poLcqn^xC(-o5$8-O%WKj=QS>4@)-wxrGQa1DSTeEMAP<>!hM?>@R4%;)4QF<4+ zh zTG<}*PKgxcvyh7LotrM_KjaIbC+vER%r*TgvA}XF1t;1r=QB_*Y&;r!CW?EoQf+KJ4#qdawob#zbcWHi1}lO&roMsA zlC4Gq&FOj>)uca(dm58uTJb1~uS@*EO<}Rm9M__ecxOc}PlP>RzjROYwF`0y!6l6Oh|&^{KXh{bE#3VoTN9dwxY^#7%0xmQLwe~_Asz*Z}ScnsOQH1 z;llC}`$JWN<+~u*P8z+T@fCqg(mR?1p`3xZ+^8zspMo>vdw&U9*y7sqX>b(lB~I8s zMoCHtupw#QU8vL&@ZB`u?H58a_vT62^=TxQiO~4;3|7BMyZCK{wBd5!R|4KRcWHk~ zj~=2CK62hs;C=mwn#$vS?s(^#65fQPGmyyRj3Jwo0nKXFnqECLVqX$}z2|E7=|w%v z+84e5id3-Yc1F|(b7rHSx8?*+@r|v}u|uEjw8xm9D}P&my{FHSP^1FIc2Lf;er^mY zAv$OMQKTrIdSism;!XPaJM8I=R2EU*khgF}Jtj}3g2a4+EIojvqyx4> z$}=eKV%f1*fIn^hs#Y%gi!)s7w1NYzg8j&OlTP7YB8_I?tttsJ$Xqnlf|5SATS@-!nUK}|zF{04bT1u$tZXsf#fz`0Y=yC0$ z62q0!stB!&F(st2-dpF2l_Mfv>{%(co~G!RnKMK?3dW>*>3+j3GlK9h<;g(PG}D}F z|Gp`3ekUd8Zx-?cW6ZdpfA#BRCU;l=J)_RCO9q5;Rx2gp3Ii``Gh}Jv+P6`aOD~#d znXNqObTyRcrZskYe@j30Wo3;zMk}$t??yBslmLbKeVG!Hp#K0lS0UanNqFnb$4%3D zPWn%zihq^rno#bJu_|`-ieMb@U|_M?;2^~!Z$7oY-^ixUEPB~iW^HB_Ziry#R1Hv| zHS})O4QfK6VR{@gYJd{IlJ7?2Y6bGu8o&U`V+*@~DADj!*%d&NC<)LvrTwoG1KHm# zjk}SVRmYyYE;|@46gGBVfRO2@^AHrysjk@qM*;lrMUIX;2vW|%*%>A|&KYD(9fYZ8 zGP*4*HGc>he2TL%+I&+2o2qJbP;Iwf0OmSSSc}A@DqG9QJ!xPo&k?g*M+;GN+0SZ5 zbldxb1N0|-rE<;HNGH}U!2;>TI`i8-d!}q{kwV6Jc*otn)Fg^b1lBOe zwjx|F)StY}thuI``fPk`TwZtqvTq4b#9K{Wo&Y0ommv&~M51qx4M+PjtLU9o;$POt z2Cr(yS?FQYzMP0nNvkKMm>z&zT0o6LrDLKQuoGutS1xL!VHrtg@pVUZ(V!LCUC|@e z5jTj=!PlfSblx9P?w{FK1-VjJsKeU;gEyKrCP+KnVbeze@_$sK08`oC z9dpqG12~oaUbm%@tmQ{CbEmQ9UxnNMT+uCySqS{g2PB2H`FB6F z;@^Q9lhGliAHNLPnqf5X^2z-2)*$gn)3dxKOPLBShQ=E^I~F(hvOlBkmUvbQL#oBT zMfvS?kdp7%7ETet7Y|ufR95nlip0 z{Fgo;*xV_8jbSeoDzqxHZ2+Ojs@p~yd@~2YwPZjJ>3sR+!R+{W*S8iffAI{l`!o*E zFSj0%_vPGXE5^81pIj~Tv(pYO?QmKj&OH3;|Me+lzebX0*f{}UC z#tg@~C+j~x=IURTRR)a$&AB*}U79|TXzWZFIy*!#D#9e{i&hD{EOVsj2c1I@pNK;6 zt$qJRD(>t8!NmjJ1A%0L@Cqis$EF{bmjkfh<9 zTEG=`5ly}4THPRUqIDq-KD7PS`_O59=Nhk3Z523^s9GQ=6?qlLZaq8$&txUy8&HdX zj!44&=PT#jU+r0S2-n4Lzv$iFG2} znfjGEKNn-!gI>-TjA;H7IVivm7Cuc^4YmyKus}&_Og3i}$iB)5#6wkxU66g~>Oiz} z&w&4ns0lxgVC7KnZ=p3+&RUT0tzaANg5byR)wj$eSy@e-^fpq*^c-qagpl%10;~0N zxLmF!H>pxf(9i^FSkaDXl1#OHyt=w?}8Qeqe4R?mYJa6)U;?M+I7w2?~f`CtR zTFg*+Xl!?|hy;N{+H?0H+bMg8kg>fs52q~XG_WF3nnDW9FP9f027(4~&J(|z)D%&V zYNT9TJ;@fQeE{QrAxrA=AVNs?mI)TbepMHmA>oNW)R%pUy!m{_TvMt%j0BX5MNa}y zccF2gxyY*(nJ_AQ+Y-7zj^<%0{``nITgX%rRTIUP7>6iu^f^*4dbW)9RkA+>T{GI| zjJ)nlKTP?>N|SpiL-Jp0DqHb4c}~R_?(a@`QR?lm{e4}OM%Ba~QTV#lC9_KhJgqu& z7{3!qnUxxml;%;@WdG(zb@oL-5_FjBt;q}qZOtgU#7m*Y@g z*4Zalmd2I7mP+0IIzz9;SLH+aH}*Y(p5!-DQi2UvFku3Z^H0DRPB2*rTe5gdH?Z-0 zYSg(?G^pNA2=lv{WlHMFa_FQ_;mSD5+@w?v>*H1n0%sk~`ULStlBGNe0oV+H-};9q z8fDIcHY!=t_~Pg}$y8leIopcJ(zrn1ZVwXN5+72s&SXes(KB-Lr`oJIgR{A|kUF;h7dQNcYNaj}9gRUAe#hmzMIoVy3#jp@4|cX4S&Y3N^nQNs@lbv+8|&D(F* z#YNuS^|meFQVH*uudt273Phi&YT=*j7p_~@`QJO14hIZ7kU@LcKaZ0oic2-=) zvXVY&{;e^m2HfGHPM`UKJq6$aCNaw8TG<*H3;Hdw6sqQVgR!^_Kzw%-3y zs}EIfqW47$+KnEKQ@wRXpx#L37RJiC0+kE#_*ALG+G_M3y+ghzM#4FM;Wz+zrA4LT z=b7rBA3b;d`JmN?MUOM#m2!+=@bSc$)wgU$5T~#F2OEBVf>}vo3nL~)@09AUI9R(m z(Iv4@v8ccM?fGG=rtjdxMOcUCezCc@=|@zq)XstB7f!jW5xg7|IZwqNEehOV4Q<1!lD);j3?=#X!KNfU{oa=W1jSDE$0 zH`K!CF*3B=2ixwzm?#z@gETZk$CXauQE0-4GtZ2jBuC@}eP5nQP$pOjX?1w6V}*X^ z4yhz9C#RX?_9U|LP~%RE9S2-m>rOJ#G-4(CU*);Jw%1qu&R5p_PB>Wn=7L@dK>E>E zRNND1rAxIy&EF%I<*^$oWEx<|NAWgiTQ5b4{0+k7b7mHj;uc3<^Qnza<f>7-PGIyfMN9eh1K!I)jC(m%etYX+n@zcfoggYl#jer_VvuAneFJd`StTUX zE7g@MJiefRI(HU;sqWJlef|ehq$*6LWG*PS{Cdzsz!uJCltL4F3yYbk;ouso% z_^0%KH?u^Scvk=#7G4v%ow&u17xs}8WPgPgjV)WgGnhcrOYbTeTOj#cXCz(ofO^oE zy?olE)0O~>#4+{S%N*bA z?}nfgBgRsTg(w70l>E#_E#$GE*Vry<&Jenc+YgFDdx@SWmb8>c?yC&y~^qQw|Qp`D5EU zu5P&j1571R6>f15_XMYC(j;uj)7N$9^PiEvXlHt>(g4uiR)Dg)^*=@bPy5&6p*)Bx z0*?wnZV5LbJvecM(s->EzX9Pcx*4W=GaZv&*42_*9e;DU$JBxGSkbn4vX`(LHSP(WIpT#e(LQB!*91%E6woLn#2HTZ~Tder=ST;HD{P34&(5IMta%3rNXF z!`C0P6w5B8VWhE)IH;s^eDIO}P7n-mN-Uysorm19Wk*zl*|8pJHNzgb>)}S}4kAL-7hr< z!(&l7X`3&ehehvZVaT2~;&g1RYSVzBlI2K1YQBJXkqOpqro*%q03_TJrAL2w2eXE8 zRN)EQr({tikHB?4_uxi*{NfLkd1&(;GDM>Wk1`d zV?cc1ss~7oN+WI(2PbEaJhQX;)v3t?gcH?EXj>1MTU^msSz;NS^7n@;anRFrxt)D% zQHD{u@dS7`leiorw{5+DZ`-N2U*YL$GaY@K=qnSNmXJ~KzntLk7zQc6gF)nw@T8|j zwD>T53GSZ!Bitux5VoKDR=v!aSbzMy>Z&|u?oih>ZqyX`$l*nqLG$Z^;tb)c7cG!+ z1KT`*ALSeUU9nc7&%DA+-?VnBO=JK!;7$gKspJkLo(X!CJKn!W`~7<$U9-8w_^I^0 z$8&PAO3&;SKI_eJ9}yj2-a-W6rxX#HG2+v!ZvoZ$_pGU=eC?XLs^socI-z~%dlT^V;&s5&CnR+ z!d+d4-ibL=s|pC)oJc{t@I~rKuoN?D*jbsRWjj=mqSJgC9x3E;HoP~}wZlG&@PKPb z)9H$9eT>Sdg#y%r`aT*(M97@vA;ymr<`Srr8qlp>lw8P!Y07_5Nc;K6DfRTnLH}yit>5W}LOwo4gvCC(;U)X31U$ZEvx>?tFaB-pGeq*!-oYyEtXpuC0IKYi&L`d^$)hYB)g z=nKX^tFXB?Eajel%)7YO0A7y$976%zK`=cG>$M|%XmU+5+hrLHX zEhd;3jo&n)z?nmMshy(4v2zyI$eNWY$7|4%)Oz(r`BRnuQn3-v*6GLzp*k|_r!@S& zA|suL+Nl>5mTxV6=OdKzI2`Y6DCWQK9{3AfYPDSX?-<3Fa3F$z=)*!sg&~~2y;f3^ zqO{s}JlFR;S7O^PQU@QU=R%bLQJW=rab-pcqME7*HTJBT0v&ho$@^IjH4TpXJ&bbi zJ(t9!7*J1CpOszxGM1d9sZ|NaPpba$K1arAmJr|; z!mi2W-M)_>rmnrLd=|HC>m|@War2Fq+9~s|+iqzyZC<3hpyDdRXy-CMkiCmoFaR4~ zM~#Jv0YT%2WPiNBJcN7|+t^DNx~XYIf81_nlr;C7I<7uY0U-|DuTh0iDi$n&NKNDP zWki_iQ@w&Hc46IB99ok*OBXwmd&xMwIev6@W|G4I@Aqm(S%Z7H9QZ9eoZsRoa@_Y) zZWna$&saL#&hF`Gton1zx@7Rc_5!Ov$)9oz;N|zm0&43lO$!Boa)}KqcT~+}V858U z{8|cZ&{obHVM1raC5$2~J+{o)qU{O5iB&uc)$^i*xzwiZwh*QB>Jzz(IC@tJH%ukN ziX4&xoR%9wT6okesqfhQ6Z}bg?A|abj9}VyN+4d9zV~#PUzrF9x{(j3JAwZb`~G>35$n zm6{MR9(1V&Z_>F9%ZwEjhjm!NINZejFJ^aR4QbSps5@vkhx))D9DVZ3z&c8_20By2B8yyT|gy~s|;zv+M z-|p!ncRH$i28HULJSsD88NYknC3@}SAEyzKHU1x4;VpsWATo?bX~4-5vw|NHe`ms* z7Xt{QaL+_ahcmWVd?}Kh=qcf z&d^N;?)mzXP^GiW1Dm+hM9WnBH!;G-Cl8ONij7BDp)fR(c^;upsp!tx>>PJ6N(HLJ zNIL{{teU;F0AE+L+4{O@Y`I*laG0IV$#+I~P!dks(7D}BAwAw9_;)epXruIM6<+%M z6g9^+d66?K-I3KL{rCcAFEb}qd-cZViwvf?&v|qa-NO{YJQQ}GLRD#)eEBvXZBSVo`#NAX5=GTA z(J$|L5F!#_JDEDAY{r?BHey6>N?^=$JSHPZ4Bg|YVj#ZVSB#h^_tv;j?#u)#l%Soe zqrv%(#F!w#wYPejO{tBFfZxQgYbb%<)S05S1OthTDIh(pS_nJc%48T zhsm>Uc-h*c@b&SvEpTO&-E@>Z1U5}mmxsvbTK10IPe@094iY*b2dS{H+H&&aP^ZLb zfZCt*%vx|y;;_SM_{5j`4AEb~wm(IcRxerhTip%J25C$i4(}UpmxG)D;qkDa?)(ZKu|5XmiaolN9&8F!;1Zp5zC?`ce98WhDM*6 zil#ggW&YSs?|;WiIr$Xp3j_WZwBNjW3o86yT?x};g^l@+0Q@QgWEz{w_9JQyEmlC3 z`emRj@NZ9PCMj=9JhPOT%N|QlL3O)|&(hQwNW&~q@_k;SU*=G{z09yiP~Op(J%#V{ zr?1)i`t?$uW8(3lNUSC3=dj{KB}%q|BjDtog>ydPr#OtXkV{dCljxp76}N2E0jw4; z?R98b2hoV6nab0k<5=@-hbZ|HetW|wV)$^y#`1M(#d%mJ+Q566ukIQ9^tpTi5h%s= z8i@aBS9+mFbWe#P01IJ+o1JZfW{OY>v}|8Or_e-62|e7lWVa?*Cinu72q3}@Q76Ic zq6Xl^wj_PgEc^wg;5A+;)$~_$EjX_+hOG-py>_~-u{V2`wZ@7aw^+<LjYG;l^SS!I67F*1we^8WK8aTvTj-(6bCh3Vno4ZcO71tp9&~ zY8%`dUsNZZ#h!$m-~V#F&sT#sZ5hFXAk5}$3ipM_NFSYrW~a)_RmhVWdld zJc!+U0;eBbCr+=6C}8ZflXJ7zW%nxd<|+@vV3Rp!HKZ-R+Jo<0E0K)l4$X zQ59$;FG1aBXLXCU(*B~dh_HGHI|+lPQ}Az=>}mdyhNmH%M53U9s7-YY)9_~V62Af> zLW}*q?8~ykr2|JpC1z5H6ygNJJtS1|2h8%15YL|wv{LU19oW}1>x5&Hs#K@a??i+D zdhv!Foe5&@T2_*7B-;(Iz9WM*UI7+edeD~a1h7z^`pB`;SUm9t%FNgDHYQ{3E|0C- z-%RR}#ssu{Wh&5UD?-r{?eTUU);A0C^?qt7-@*CEMA-6sL+WpqW|RaPnA~`0wg_rj z(Dde+<{t>~`0xB(gn0N(+B{K*U!ahxpxdb_4*Z!`RTd;##6D6bBU2&ISRn?qTTr?_ zFRWx*@=vvNLi|)`Vt`L;oxI%Tglv%c1_}Ek7p}E0lfZ=;Vw)3$-ur_N^&cI$^auvUy3cv_@t_$UzJ`jH%Un`|#5gZMnFAG6mBVy0ByhJd6 zB>GUjQNTFEBtD}j@3vH;G3#0AG#)hWp3xVp%DbeQ@-h1wq}6_fU>wpQPrdfC;V`bg z`nfFcNxc7B;|6iUV0l`dTbxm#JClow5Ef+i-Bl#Yhkr5xH5|j z@trKRrczY{LFHhlsW2|l#sVF9BJ2u|P*)sl<&#*$6#gm9^!ebPzhA__gndJA4#!wS zUvHpT=YNMxp@C--W~;edVr}3&W`LR~;PtPdKtS#NZg>JM?4w8r=_KU~yu#&m{v8X~zkM>?48cE1gJ5I!{L7#Nz{YX4ecZ6;Y|l^Ywq z!!t}o0X-m&u%)0b`eYSc-Nf(ARzTl&gxok8lYPNkAVu$C2l0-|G(Hgc<$nFQb|Nx_ zi>eK&nh>`y`j;>Qm(n3x?Q6d6&n7umav1A$^%4Vhh90?b+c98vg`?%Uj8OUfCOqEJ zs91Gl_D@;=cS?I*w;D-<$jxo+gT==G`@x5xm>+F{$3=q&0UgxJ zAJku)y$5BlBb60#3qZC-J~IGI3&9_ScKbmjO)jr4|4 z|HrH_a%kNAOO~}IpOh7+5>&z9RHngaW2!Qa~JQe0+c zDit{LL}ICLmht>#XWV`TrkcwZNTLA^4;yGN&Ut-0vX7*bpCV>={xS@u(VrP>v9Y63 zCeeq)!;TxmwntWo$~(~#lYJcZ)G=`w0jxx&&E68(GKebbe1Qa3ZY@#vW&mah_~3HI zlT-=A2m6jKCfas8j_fOZsf(f`YnYhNx!n69R}*a* zWn0|7`cCW2Jx_WZb%o)8R0>8ZV%ngDip)1K;^owJ_ok$`s{-V6>3?h$+q?Ty?NlOs zs%JX1pQO3&PdlU0!8S&}L|NqQf@p7g^HfkEMA-<1eS=XqFdye8YvLfmpW9}R-Ks(-bb#B-KN2nsAZFqjLfqhvk%$#4yNMgh(Q!Lr{!v5bkjgrEu7kQeE? znNr{2C7(g$&!FYL&2M6O^H6#$Dr5lkDpVNUBHc1tQXjI~q`4y)7Y>;Y5ed6|K>?pRi18L9ch%vbD zh{qQ5QzN~L2?eJ~^1e~fr|2W0c%pBK;%!JPy8{y@^{SwPAd_@CumHguRb6M~E(c%) zPac>(4mik?=BmBxO&Kx8ZsQS_T>EtCSMDy%EmtI$od<3jL`^Nq{cXK#zX@^0gaxhF%!T*T~)KL(f65vNVeVUDk zO7>2jsaXps19Cx5fzGXDtni!B8bbx)K&hWh;i$X$kwsr2UbZ;k%XAMQjD!*>qU4N~KiLit zS|SlG!rM)1nOQ`UuC@H}>Xuc_xKY<%pyitnE ziI}P!b9*&&^#`3l708N( zZp_kVO?&pA8L?YgIb^!Rh>_78OT0=rz<6Q^B3ES7gcJp|EvbsD#c5EHbNHkK`$awS z+;9uan>ufJw`y2P`NpHB!aBEtL6eW67I?gF-mSf^H3}oKTHyA?(}VNWlSPWPAuNQm zbsw*2TggeKgp;FNW=?-5n(&`E8DWo3EIx67d;ZSQHw`6o^Nz57Qu9)r1TI=sxL@}Q#sxhLybkGGvtE@3U+b4PaB z3A7=5ej1*|t+(d@}%vRzt6A+C{)xv8ZhxiYn+wRBS3qBH@O5qnz;84O5P z)KWSv*kP5G+;igyY10ppa)myl9~5`=G5d1O6%az6e?&7Njv~%-pMS@z94loucn$-d zLi5msNlG=^8sJViGP7BVnoI+*?Bgfn@EG>mO=#jD-${z1>5I*VA)O;Bk1RFr_PxZg zy*CrCO|0az_dwYF{Y&O{y|OxbiAD(})MNek=$_k~$it(nD~QI@@A=Azs=5r%3gg9y z{XnI_oPN50{W^kloU)owANim1g8B{*)uWLr9i6^I6~zcT7WK=)s^?WXb>ZP~;@!!MyBRfHlICFBr@($-c5)duj=h zesnjzzZ5^LH3OH54E92T0IX<@CCnRQSQOD35rB$+06?B%9TEn4t8bo9*xGS07I zF%vAoWv;|6`=00t;RQOVCfe<3cUNpnGs=Xknth-7iZ6)+*O`jh`?vEzbN5P=5 z6;1Z=uTTV1=dp#Eoz9B^@8wb8FSG+gM01x{olRWcAavz&28Et3hkZqyux)N&<-;kl znZVp4mnee*Gfh>lg`xhobMj0^UYmL8!B0#~BAtT_B(O8O+QpiWT7Xofj8 zgOn(@|9M0Xob!s(m}=69e}p$!rGk_EevVCp0!0=730f$J?7hu*+!f}`jMJz%J{zX0 ze70eMdMn}o9-3N71W?7qUw9MAr{yM=jeap=MCx?W8eC@%7PN>(NDIIU$YPo}I>B9J zXtu$?<3Mh2gRd76%>(dn4wYy9lq#s|A}`^_W}8|osoT$E@fV^t#fn8Dq7E>f?2v6V zY{Af{X(9Wkj-ID9qeD+%Z3HtEtgFi|HLaJJd4hM3u*G2C!h~BQi0vITaUfV-D~a*z z#SKrw4&5kGA7!XBj{vGsSUmRqX;-#`yBK-$o+9cyyRRe@xnEJ^ff8%3w$}XvYpX((4;WSTMZD%=MLnI=qwNEdj+5g5ePe9(yw}R{t8Tul--D5#r z)->4ugzc>y3%rEUsq8enoPU*c#SbO|_L5!)Yv^nI4dH4q~V>W#-a%f^j_A^SVt z1y&$p7tpQDr8S-$+)5o*sV@sC<11N$e^q=jyV0CDJO!Ap7GFs#+MxY%aP4QKl#*p-PeR9pRPC?>0x#C$n-v3)m)43~;|JZ9H^~zhQWOYX} z6wcxC!va9RaS7sg&@M#b>|&0%Kk(=AKgiYATT%IryfZTwbW%h8v7xR|Er>wCufV!toC<1tpaz!9TrFN$2t~yVUo%%@Ir-dB%K)ZEQXAA=gmTqNg3{{RkH)}J zIH)<`KDK$fKk`^37Zw%ls~q--fm+AxXLuib8|H)d$aYfiFO1kfMEym|r-i#MW&x&L zm!?~pU~z-KBnl%)YGl6Mad@t;2ua~U)&Sum6MnbNQT~peU^`H-x12C1%HIAAGvB?D6ncNDS-|y(6D*2E5gmN8el{DlItc1Fu9hoWHrvFh#g@!`+-c1 zpn*qbK7WSDfXpq{%J|9OIZB=56%eG=13c|0dCw2grTr3nMV4Jnj2HNXiK_vvpiM-n zM^3n#Ma4~`V8}AfC&SySOzjoU^oC;XNzLuaVsqS#{%Thr@~<+)Ij_J+4)`YG(n59f zsp?-xZZIWMjOOndi|$uhDJ(r2R3K;(?^dHB9MCJ8>8^gW zcA)3I=2-uYI1aXCR8E5C1JJ;lic;fbZZ8nvfNEY-A{9>FltNFgE+`{;wWb3O>MJ)+ zuf$@cXH}k|8Z8K;LHXU_rgsUCA<;mfP!ZJA_mBC{wpu_7dmTr*X_(YOr_NnxK;ye# zl;gumYlRN=V!$Vxe~%TE54YjPZC+Z;S(-K(;pEIBQtprYk;mjU9lK~8nrBetLRB!G zg$E%J@pOSlt2ugwOye3yqAe!DE4+D=qHdPuv@u6%NJH>pn-zQzWPUKTAm>sCRlgOf z76?ntvDyB6EF$usZ_UClXZds7^&U9eWQy~s4pDf4;-&6vO_z)cRXdCP?vg|XHfHHa zID_9`Q-Gl(cjKs@n7FNZnqdyXrd48C=5x$mZkA=5hVdji<2f7nj#=Az46ukPq&ihF z`Sv7V8B1s$VtCJcczegA#9*|Q{ClX;-4Rq=fx&CN+-Fi4l-#lXW6(RqyGQZryK}HL ziPn%W97|{kPjeuXh|;~nazVjCc^Xhb-5fb1V@UoGNA+HC%9NxP!Sx@Mhon=XxPTFV zCYLiDY|aA3CJWGIlWq)whpJbs2pVE9*HJIUvb=H}{B>4w*=_<$>%IA8(gP08H?yHA zXe|A_5XXj4WK3pG714++_#!kl<0V+ePV+8!-Dfp%r;64<2jWIG@%HG3v}%Z6GcdOf=m_>Qr1}G`gJ{H2B7m z`m}a}w}k*05!T!43=mCUcjK2scc7}3Z1n$0Y%=M3+DRr)kduRkF8$ibbLobbC;PS|BPO8MHOC&gb zyzbAOmbmU{s>)l0=qYR&Wse@6cxEgHKF>6qr&1MIM~jwx97TwVV-&-`$xwCRZqyQA za{9^xM{}UxMaiR%Bg`Z<3-0G}YL#TRKl{$9+jTX)JB*-!!nw0<4h`Qb>2l<#B+q`s zl3|{V7D|l2FN@Ni4x|&a63Scan|_0f~5LqMw?;_b5I<- zJ2sSE)|Y1nrr5X3Ij#@>?fJpdsH_K_NU}sA-Fy!hDLC{QeL~1Jeu5OHkh*H)v7zxr z8Fv{ev`Vf{J!|5ecPiDZ3N@z5y%i-7odBHyw)?ZAM4nx{C4r!}MTU}#net#iS&hC* zMa2hxT6`V1ZOZdvTE&QrUZ$AU6 z771Z-@l7>SNL%z0|4-rtqj8Jbmb<6~oA^x)6XWU zqItVZX7#XDAxwH_@9hqrfwJh^kML=+=bLR4=R&6nnw0l{8_a~uXqm~GxFwc^+=RG? zbKkYyW)D1HMt)RjV>_KO4i%HyYOxF3+X)$!x-&Z0MM8bcsbIrGo#CtyevMZJ&yFa6 zOWOnNs#A{TP;_RrFC=-wr$i58n`8N2zC0AgLHGTyQ%}4GAwQBoNES!Si5coTi#pq+ z`^1ipi>p7iBoD+{S-DHpsA+_GRQMDtQk_8v51&H#i8cPIw=&kt#?<}KD9kPELp0$2 z+ttY#%oI&Ru^pMfJx83bRZhomemH2u2G0*Ds8^P1aW{0Y>L; z8DrW*f!VJwIFZ6{PFV%lQ=w25`vs4<5f?$PH>t!5syJ14fSZSw#HHoID3>a9x}_eN zaBKSuz?jg5*t}TTK_qIOe2^j2+unA#c?$B#5(evV=IFtVw3!8Q7Llb^9Ci@ySuL;#5>OnCu3y>;)WM z?Y+45*nTIC%KCyY(N}ug_@-JGP?OBmAET#(vJ$r1#u@94i6?5jCbcsQ@&YpN5j8ZS zDu|JZu8DHHKZ{%VXdwZRWOiNFt}_Y zc%+*lVz{ADDvomSqp_teZVctI?utP_0{DVsgNCz?=?$liZS>6oOX1e-JDK$uv8`Py&w(&@P zW`7v=M`v09U)6?Vx%Q-I!lF@>LPe%So~*^u8~`fyEoYpUCkr* z-TK93G;hMvww&uz2Kj^$4fA`3x{2BoC4FL?9`R?oz%X_1@__sj{A2wOJb#$%NqDG5HckCN5y z$(%@_@LidM{F`2qwpg!kM)o~EVrxM$^Z_13d0$yiPmshJCe(V(L#O8hBR(F;R zaA*JW%-(*{8O}dhwfsaU@~!@tbb_4#?b*O*Bqnm;k$}IS5XG9e30(3W3P22H{sMxh zGFWZ6{?0V??M}@yJ0Cam*E)=Sn>n4rXacl7Nulta5{CYZH**u00|RVoACD$g;p(Zu z$yfW!tU)LK%CW5ZQternUMVS*lR_nFgRGC#!?FiGpH_d+AkjKo9yzYuwGNY}a-_^^ zZxhPoe#Xo6Tv6?^lfwFd6l9Jh+&-`;b0QSdV#rg;0jKfIbnOf(_H1jOZcb` zlc*iU6u0p|23dh4eN9pCU!-J{<%1Go{8ZKRqQdpQGKC@h1`&>ud9C3XWh_sETpK`B zZ}m%(8&t*6CIo0Ij+Ubx?`FwJEKTWlIa;XiPhY74Ktb-+Bi06LWF)Rx*|ztE=3tw( zpnt@g$PP_Pv&eNkWnhQ{C2A{0LlxrClo*e0o)LCJTSN4~ekix0Ip|f1A!!Bbtwn(^ zHC~%WWbJB7io~OuQ)k4#i-gYpuyGj2qqFSr=fx#@Z}?d9hx!d#s+71tK{R*KnQ4Q+ za5aD}p3yMSmYWT02lxAV7Yy1cY5HFCQgi|EI;(PpaT<5fL#r1qZnVZ6N~!ggj&}4| zSQG{2)%Tr$~Nn5~ofn9$*A2pHg{ECoQ4yvV_c=C2l9;p#v=kJVK%BZAa38kJ{nDIZ=Z(GgCE3t6EQ}1E#aesR)vfnK33jd@GDQlOu zS|5g6W@!l_HQ!l~fbTe`S)xb%uD%{(488i93D~KyjQ6?ER%=j}F;g1f`u5InfM zySux)1(yM4=i9B?zq?!e)k@c^nwqLtGxy!T)wf^Yb57e%_a0!w7>UHw^d+@edLSVZ zjo=&o(R7WZzIi_%kRcy@J)!_~52&o@(X1iDGNYpv8|sSZJET%Oe^MoA;m{3fnD}E3)ZnyCJEh?a7OIPjzX`G*0bWG2j9$J*)AzpOV?w%FP{Lu?2OARS=}`|f)9 zcd4(uh3vdfiwd#NXm9sii6~sq?idY_`)=C_Nv!@^rCEt zoo<#v2A{*k6j+>6-j;1u z<)0tkAu0t7z#&=37O~mS63Aq*{9Bk1b&PnKWmiA>g}X4Qum}wYJ0WD1;cxF3N*5-0 z20{8~zAXfJ31S6w0{{+#7zgfWB!p*XmU{}6jFFuIhr^1n^MOK@jz>rY>U^Q zdQ78}#F@H%)mUKtZ~lL|8z!$0Q>)+h--Y`$%fOFBq)7vg7IM0%^7?hJ(Q$<%A$uN{ zbrDrq1Tq{-xnhRgPb4*Emz_ws3q$}$?aVUY`7NI(YthKx4Jr`Tl~GBBK>3*f!@St* zGJ>F-uq9v;9jW%}?0m*oPCZ7V;WL3~R=!quhuKRNXYyfb2#i9WN#pO^LId1i2J{WR zWd3S?b$4M|_ve8%5)DWaxg6MqNnXhghV>!N&)VE$Ya>a`-j5(fmG$`Fv^{^#R-!jtUhfO;5lN#h=fO^qH_-6IDeqZCsb%_ z(2C&uTNOXdc9r*wNObHi6GYJ0nzpj+-05>+U_y(yV<5ZjLsUX*FR$AL1RPa*lL|!@ zFppBV8=ad#o--(<+sD z@F{g{dwsaKDn}C|4NZ&$YlVJ~va+rCTeLVG)ub1a`TqI>+lOc&B-Q!qys3-zd7PC! zfEODy6vSfTkR|m~u8xTy%eJ9O<8uI)NtOX-xQbr|E)4&`1Y~y%R#81^U`rh-dM&2q zM%PZ)LLl3L4>)Z?cKO2 zHmPIlotF=%{c2b~Z6B@xppHC@o#qu6=w@)3T$`ZaQHGHf{l@W38dc*RMnW=iX+}Z2 zzA~@%A6?M-_Q$oi(bcwzd7%h!2(aQCqD6335N=!2ik2Hg#ofXQJk@~+eSj(P@_ia z^VY3WVCls>@1eQ0@DOkd!XH52^#uostmshjR>}g+nS#)P+9QtECJFUP5Bar*&yb^2 zxu>d5vR7*-VRFOV4=cm;f^d(uNBdO-Z_#lvOB0(z5ntt?AaYc=QL1!-BJ_F^A6eBa zP+-5d`?9tTehMJys@}_s# zFE~o62FY3VMYS(eI>s!>L0F!|fX?P*g92C#c%hDD3d!HAoBi**>95auc;TQ-e2%#B z%`t;5ML@3Q>><_t(?VHKZ3}(#2#u6%8&arqU@23#;!xm^4z&5cvEJ7=!q*YpDkvYn6wI0*?RNAv)F2c0b-=a;+Ooy=We^&iqX)W4h z&jZfd1~o3|C23~`ZaKRxGi8;k*P03DMV06KI^yQ z>En-YA(U;RAFRfpLR{ z56cNI!MO4+Be!RSo@nO?>x&0%vcjC(4Fu!=knU#51Z$Ry>%KQu#OggLtoKAyy^9)^ zm;sN-KBs~kgoKJh-m8aZO!m+wUG_D|W~4NCjIRmCM18<7C5;)cSr?; z>EWCo7l`hKtbkoDN$V@V$6V(iw^)-mdOyFPl~X!vYc7?diX2QsG+#cBVov+Kr4h5M zl7N9~}vdL80U@LpzuyHiJ6fY|At|a_E!bw-wzjDSNoa0Ve#8ZAk+%!Mq z5;9uG40N|As8wjh5^hxbJdQ^iPUG|(9@$rhA=UZ#Mji~hgfQu$7?6CWnrU&d2|vdHuT* zn6G(SJJ|w@%v}n8n!zcL*SdBbHhnXs`}Y0uK+%xsRN}xP*~PMmRyrBeKJDJVnCz5~ zdbk_Y=1m>iSj)=^Lwh!`&t+g|B#)pTMis+@!y`YSmCWnvXKzJkHlAv(tsI7p5JwYN zn0?pU1XnceZ!ZFh6LyTnp$e0|K;42Rm9mDYQHD`zacL?kb+qkF3K+cpitbd0{6+#- zD%{9zFtFG&lHJCw68jscM<1?J3{ zV4|2dpJv#`>Cm`kUW4lt0^B%ruFDP^Q!odu)A4Jgc5Fg#^w*p|%xR_|T|h!kpIN#2 z!Mex!ME(p~xVWE8fR_Cf4x%W4M2gl2F_r49jFt$xJT(lnoWvZ#*ia2&K=zNxc$@w# zDeP$J50pa4dzeFUx6YYnK%ZUh&U8!;6si5NHlXZ}o4$V%+R8aBMPsKgmZ2Y2Jp8}j zUz-;;b|HEJ{S`w~ucKdJ>7RUYq*5HdNep=z7|*+ojZO%6)_ESWo9^7x){oJgxs)*>nu!fR}_pR;eKy5xl4Ts{wV%pH~v0T^A?WLm8F zU*n(c_SKYQK#{+XYL`{8M76%ygRexcrtdMcFP=0bKBc&{e{r$oz;5aLd&+<X*SpF!*u@O=9T+6t&KOe?D~ zYm4f95=u4{YZL&)fpN`bYY{{23WJ(kmZS@exyDjUc8-L=JlH{ybF^yG487NR^d&3p z%C3%B(7P*WSdsi>ntsk|;%J9+^1upb={foFZhn1pt9BJHeV-6C9nZ9 zU=c#%cSdCY{oFfK5>o&(d0qUA}s1Lssq=1CHDUKwXyEmH}JO+>? z-5|w@HuL@b6KEx2T%l#*Ii`z27&?HjoP)|Y)X)izdgsDI%xM!_5! z>Z3=+<5i?78Q?~Hi27KcP9rR#k!-&t=>lyJEP`abI3fY9o{vb%6;OTpej!8@1t6R=tGPUQQLofj-m&5CMa8Un#-D8g11 zS6km%alwa1PNd)DDNd31?Y8JWM-=}d+}#=~hvUKY+MS$Ta0gp>jBbzUck~@5P_6&* z8B}il&qQ?vR8^eenVsBLvBFCQ!rd;cNSaGSe7xN7^L}#W6n1h}8e%t&-p728;szOE z0gstU6LADIZt_$R(vw@!+Y^YHtF+S(<_g`ax+%W+8BNg8Tz$A$zhmskuTW^caGS=~ zJXTcl$J2)GHtR~IAd4`|(Ul-1DPk05mXd}bxm0X|o8yg!8Hms_KGhVl8-+Le=Srap zmrX7a`X~2E{`imq^$rHbq40H2qD{-~$4rGJl^{hAn*V^xv^xrC|0w~(r(n|(g)3&b zTu6(p7Pu9)|EV}S>i5}$6j6jO-phM#^Avq-oK&nJuSy-e2MQqet`NukF=&_C(+T8h zPlTo{SCp-?^E0V{Q7*s~K;vZKe@U-~_XJ>*jS^3_>b9XvGqBHIJj679jW5Gj(u|Za zNY45MYob}4KEOe$5;Iw*roZ0nj5SiMa$FJ_(#|Te0&%S;`I`eLx9^8MP&jHgjIA}; z7D>Z-oJ+bU!G|R6egchDHjb9=k@+)gV<S`fJg?R-k8sgXT-7lN$ zGT*8;o*=k2gMlZX;q4cly(Z1!)%;p|jRj_Qbf5D%cr7%X_n@gnqY@=t^s36?Hb*+E zsS9^&%-pYy`Il5}b6#JW;o+I7xHSbbSwPgWp1mFjk@cn4m+KfdnYt-$Vp9z7UR}h- z2FUt|{AKOUa-+vbLbu%W!nWE(4HL?@6<;4sj}EUN_Lx7a*QcBpdVjJdoi>H=`z^;S zX5w2?24F2Gu-^>WS_+EAiS!Hl9x-7sXBRGTbvjWP=rE2lf32XM$RDG``f4XG%in+B z^Bdr|_$+)lvQpR()&aOQB@4)j$-rQ=Sg!h(nno0Ktj*jJ)5v4vvsW^AiIb(;SW2a= z0hs~bp&R;`+c%J4b#@$|i(5J63Q;*+>sRyorCa-^-T&2(EBVp6eMQZk?0SP@ zB+D3@f1;nbXjLwX5y*|!Fg=L9!zHN*NJm~Xjq!q%oJ0|HR88>*o5q>R-r#=$X(p0V zs1Ua~{4r(DYjrfHccsO(85(F+p~R6{S{)y{)bQ5SA8O}iDGl$`@tb`oIp-*E`F~uP z`P5rx6#u7PSI#H9VYzpK+#O(R|1Lr~&Q2)?kK#rYd8aF3@?~jA_gv513#&Egq8cMt z>D!+Wp*0z|%bu^Sm#8!n`n4&MO|}zjIvt)~qs+zRjwG_aL0sA-P>w`GK z_a^!Q^6~Ab@PZGV>7>f!Ajj841g#1imDlknq1|FD&u>IckKW)Kfd0Nmch7f1*2+QQ z&xy2QF|`Q$eSHZlK}H!+8tJKg(|I)N=fY(2P_~vlgrcH>)ZVOp3rB2dbzA%$ zD@nRW;ogRWOFgV?I&U(V6&nC9hP#i-Wr4Ti47VV6pE+-T&!V^ioQRWWCQEMaB5aiI zw>mgIiFt}MyXm);QEeT9-_h=WqF?&l4!f8+$ne;Fa&tHyRHVC*fa@y@z0&xLFN20B zr*t{lCL%^!P~n9H9WxZi@3p_LzR_cwam}VAGKM?Zc*M6*>Cy(X?p!Sx18)1^Hatw( zqNIuc{ayCCIiTNU#G352z;|jRrp@#Jw`IP4?sY28-hH>f?X-}qga<1Rp81JSEIb%& zpZ8S}bfhUUIhN42mk#s#+s%p*U9<4^o{u!p^yQgb-pCQXu0hWw4WdnFspD z#yxL@iWyXuUd40F5bFn7vSc1A4 zJ?0dg=plnT3vgAPTNU>KI-YrWOwx6*} zn}edJsy2LBAwpCEOd#WeNFeU~t0a&icEXmCs1%hogx>F$JO-3#GsjtbfBtdmWriyw zRmA~w5Pq08AunUMn-lj|b%HtWwM1u`^Nm4m`45q_Q(IFdn%V=SFs$VieAD{nT5DRi zu$M7k{b(K>4-24h6{RV#6__F=3rw-G#X{W2q~5#GRbeRqEo^Aq_}B4>eg@+fHx@Up zuxeP5&xM5pG~j#=B8Za6 z)tX}8Xb}8m@L+RVfBr(fsr%Mv{|mBdo}&K|eSs0Z5J7~_e&I9kQ2no;NH>fmIm5F` zxbscSIqs<#wq;hLHt^__;<0ma6s&aw1-=V{DqlQ{3Ni%^1j!v@5I^B!b2VVN9t>n+ zDy;*dV}_jz`!5a%floUgdKwJW7<)5x4y+W~WI zi*C$~&0aB^ize4_u(7EQ1YOVA1e7V$Z(vh|&FomKw*#eYVf*?jyGuV37u~9b7)s5l zIfu!ou8%OCVe!`p4#@HbbOCqk=S~8_i*xp#G#^*;og4S~5sVO^fWQ^`G5+C3>(vxeQ+wG6M2%)|7x!yh7I6G`a|yqB1kfhbRD{!@e&;$ zOJQL{IK@^>^z*F8is+YykMUE2fZBI~V&jsKxUy*Jv1JKBjn6F6S94FzwOtt2 zIo>4Q!q5?e$569MaJ-#1!R1Z?by3{3!Ih?-g}DDWI(VbSaSsQ6A2Y#|b8w(-s0d8DQo0d0{VR8O z@EZeC=Cjqp&)!{!Pji}75i{vh-PTq)K#ki5V6zMaM8h*xAg*u|4U7GKJkw^v@OT$E zC!6Umw2PX0G#pZ3+4plDgPt4i+p_u6?Y>OeGMxl>Z6<6uSYb&Ri{rC$fP6iTmTKq? zgn@o1TUOR&$S4JAR1~zqp6~hXS^c!+TkZ;-5>yjirLzeGxN!xAQjf}zQyFCajrrrQ zWAE-ZmMz=nCwU~VDc6x0R_)rUEndNmwScBs(0A=tfrr&0F^l>1x-4&tGYR3hkENzF@3N)ERj00o04}~_(0KH9}`SB2@Hl?bBuH(p$WdWW4U-S zl@Z(J<^W2hGXvoI605lGzGu~AF`Ux8r+tS#4BhyRiJym@@mN5Btk=9{{Vv~Fh5a$= z*g=#$g{{p`q*8-iQ-$ufyKD4$rXpgJndY+ZKv*la+ZiWJuTR1gW&W9FDmPT+3qri( zg|UQopr}BIn3!*Zs*c2Zs8K<;o`CFK;ZknD{f!sMMsQ4<^ScSlnt5)u*cWs5*m6h! zw|c%|KTA&=NStFz6iG2ePhzd+mf1ETqmp_PmCnJ`H8S?pYC_68KE#3_)=vP62*kHCSCOl&Ow%$Fnk!q)@{8(VoEA7Iz@8_vSDp%u8*yT{5l5A{ahC(<2^@F zO1r0V&dFE+s;YGQc|p+wWP{)c@P-~xO4cmosKtuH=py+dy0_}^-IueR=R0sTdaFKR ze=gn`zvG>s0Yyl;T?Zjk=Zj)Y|M8(Of3rAFzdIKi%y;_qoA_VZ%eidUjKy@e#D9Za zrVZ+O=`$neI81MT-{=r=l0%eo7}m9<@9N1fTxNU#b)n_Ii|ZoyQT!qg@}8*pSC#`# zhgr`99=m=l{buVo-2Atm#=PEP#X4r{99Iunm(;5XG6uFoAd@1wWEqnK&!%1t-RFd* z&dd?XgJ&N0+XlE{HvjN?BnC8uzmw*PuF-ZfK)-AX%5m?{nzU2KyE@~Yi-ra+ z49*3Z0CaFk?Ie%OjFyeONS$^QC>11t$ku=#Du(52K?wo){oa0tgAx%`m7(53$% zwot@lIwojm4X_a5?KugzW~$qUd6kH{>m|{Kp3cQS;R3q+YG2)>h-g=80-{g7RX+dA zNL*Q)`&porS|Z?x8ka|ZmLGbvC%{e~FhE2&>Kb9{>dScZB8D1NH%(Li++a|7hAbce z(Mx(BP&R%mU~bnClh02_-zhpCu+U6JV`#EwG|E``7i=)H-JH{=c8^gml{{{F@qv@D`SA3-K%Ns(mX1O+#Q)G9zvr;j-sYfsu{>8@Z z4T^3v>z@?Q`C(+9uw1NM5#l9AH^3ySV`%%jSZzFiy^4VEq%G3}Wq{6np3sd$%XbAy zOS7>WOG8ul!Tw1@4-Jd#3o_;7s2yPVqCCDGO8GGscLBPdT`w^v?|=<4#+T$Gk*E zr`u4;ti#QZ<+^e9a!AvR&V;h#zLAZ#w^li-xlM~=#7yDQ(9<#-=6(Er^e_7O-hYT z4seVLBkbLJMPUwtdf_g4j@UAVMr?<$;+*M;YSHJMWzWdj@fwd9hqV1b+vI1^ zH-klCjUjctAx%Mf@r=1N9(%7Wh;;K^T4;1ROU7g%0k(QT7jS6wx8?@ZtZ!u4SoE`G z_o+q^YoiL?`Uk_BMp)adRVhT=u~|L{N&-5HrHM)^GwZINzSWs!?Bn=*cQZGxw08huanE!8W#g)Vo7~FGb;s*z(REH+etfm^sC!UP-K$ zabk>()#vHz9d5ZlEpDx0v54b5jzrcpL78h z%3WEO6A&D!AdJLsQ4j^MU&P(&5LY;H|FCoM{Q9nh{^48M3eTs%B2Es%?Zi1qmgW{r;>zIvC*WBhQOo^lY0ffolUvjm~<5*g*}jiB;OY*9aLN<#v@`U?(&RU|Ju34tlCvafN_B#g3T_4fBf$< zEY<>0$XjXSpz$f{(KM>lH^%v+$`p&sC` zvj+UFw3;6R-Zm15(iZ74H#n zyq5a0)ELXdSSmP)On7+jL%jl-xk>@gIGN`m~@+wVI_#2&k_ zmPijJnm(dOhUI!kB$64ynOhSr=`1{jbvh}*BTAu;;zTuvfmDVcF-=E2?2*+SxT;=@ zOxGNzYkIH2Q11`M0ZQs*?-8-C=R z{voHe%TZl+)m?V}Uo?KuYfEOPvaciRzas+2+2td%8}4iVze2B2Np%YZy2Ko&3168T zx?N7%jG3ExbC&VOFE2X(UX**GS^J1_)XflQWd3)X@3fx=byi+-#{TEvv2=Y*m^Cyt zTa`3(Tx8GW2h>#mv+RG^L*##=&B*`mEmNp5L+2`86Aj)Ekp{y<9`U!{?2MZ9c)FRt z-b$C-DanbSLoq~Y<$ciX|8nf#P>(p79t3{fgVP5k2ie{G_t{ud~{b)SQ;GWXH`7tJD8bh`7(7A?d3;*5HFx;x+Rp{;r8A?o;8z1r_! zW7EFY{FHmMy_fLnDSoj$mk*%7T&?|7+~(K&#tyk-APBW%^uA~09WV^<8sL})G@~fP zO$L043ts>90`>ohm;X-<1DpxGWJgj*a3=v%Ga7&;#xd2S;8vN^lAdCbdPiU$18?gV zzzk<|4TDR`JL2^{a!asjGZv{aZj7UQfF^fw`|v0{Q>N0+{OHEdoGapk4B3BvdHy&) z%5YCyqaWkZK)}ZesTn7;XeL8(M!J|Ay}))2eyI$yja>xl8vHlnl|Cvf@KSIm^EEJ))5iW!%vZqt>M@C0;HX4>WiazK|7U&9*9;H8_rGgb|s^5Zy19#7NJXD3G%pOvIcuB}{%q zmx2tJe9C5R0Vza=Q6mT2H$s!$BEgwKc^_yYdrNMM@;-_ue7T{=Psv#AL-$oaQ4|#Bw0YFu|dG|2T87;h4mDMHQ;9GG=6+ zBc=J?F%cMH#Wyg2;FH*(S)*6O5`U?ga-OCQRgB$#ySi##v$)h{w3e|~2s>@%g$tr*1N3_byMYATX#icGz& zos<2v@O%gsU0+FPOYnnyR;TJlB=PZErJm99ZwH2c-H>HXJ~G?Wb|>~b6M9mS_n5JQDQW# z0g9ZGdSuQxo&oI{j?Sbc>)GRxV7pUUSkGCu(A_#Ds>m;1foi;ojva&zis|%tkv|^TTgsSUSQ&wFzJF)|rcYEK`ob1=){UvAx3^PN8cqNBPCTcG*X#{dY^M zW{tY60XhGyoj+*Hji=L- zzIs%coHg*aIt>Igh4B%NYWnTw z4jq|Bo2h3Ajx(gSN)Z^D*=JeGDmo)^AA5PWYpULuA2SuFDi|gllj^J|fB9`AQBL=9 z>v^7C2vm*7zl@0ln)z5obolsheLQuX6U z9`kHPi)ftvidJp-Z#TrwObp_J`;n0xq-d>v*|o!rpr*x70xjNtm3}MR#Gilm>HyMq zmkoh`F%h+nuGkaWOJX(d)5i zkgosmWytXO`s%Io^NeM?1b2(Wa{ur5$LccB)TE%-L-*w5W_y{Pra(wIA3eSUs+}US zw62g3^TrOs@Ky2P!JW6juIf1ew7D zGIm;Xor{717oPSn9@o?*AD3sLMZRwX#$3K9C<^{PlTkjm|)pPiCIlF21G~=N6(!62ceSY13ol`{paG-BXLnevIdv!bZ-%Pq<_*G@|v{_?| zA@G%LbD$L=?szHoiChjAM?9g?xgADP`slLL9;9c*@%91lA`gS5Tp2qvr})&nO}<*` z&Ze|d3ZF}P5(Kh#2gTXzTF^uu#$|PTc3By88Sw{IYf#zz1Q}x5co6C~{}K{B&&)Uv z4bseV+>477x`np)^L+AaUaf5D(*^^$X^ZxfR!sOD`L~Je%Xy`uuw}^>Q%Ci;4ThER z0iOM|+Lw|SF9qC_mj@lJ`GU~37paHTJch%o zd7F9oQ*0L0@elil?dF*nhh{WPxCa)Mi+~sJT)+AGtM5{r4YE2Z5&KM*P(!rr0$4n> z#7usvh}ra)*~-L%dblnE#y52Cv8TzaSO3NzSm)(4MSAzpCv9UMN8?Vhk5n%rrvZD@{!BaTYC(0|+b7r(X8i7f-vwKzcL&E1^J3*`6rL8q; zs%j_mH2KCWK)((#JEs-%S`*oQYT``QrN=7bD4}mrR8uGZFnz#O6X}?oje75Hb;8Ot zV5QSB!ejfmx(S)n4}oCbxqk9bC=B&s!QiUa=Z42=p(Wrr=dyG7X!*wX;(F>|vXuIg zreUnJZ{NLs7=UIc)`zXCKUQHHSB7T(xY@VeaKTMk!Hx+XhSk@dw^)AQgpgW~_}g?Q zP)MJ}@=5&HL6;(IkBg44R$8>J6rgFIqGYPK-XVRbnj3sxOU1Ib{)VgcZ`MChH zgU%Z z)H*QkbiZ9)N;k=Ze5}%7wRai#7)gTRa>lRyr3A_R<8@u4>v(Zm?>()x6{NBlu;_b4 z)b@(N>^D!{brZ#2C95eQzvWzD3$3Gv4^caJq^7v@CTcK#?3ZD!ycxOt%!2qwM$A7}sGb=l;;^jHbnR_V?%rRr~!O>~VeU?=kj8N}VLJU#+G0O!aCb zQJZVl8L6gzG;%@Y4)L_ls9Q&fVn!fvOnfHvekYgWL*woJ*R@w~zg@koUF1j*i2Z-PT;gj=yNn50DUds0ZB@(Jwp+?A%4&_|;;8VvAKum?%( z>0b}$`b=V8`&|Ob);5mQ?fK81w3SvxPb12+3?Av+%}zUV*Jh8C>d8^$!b+KIN5%QP zX#RL>gx>-V_VT)=TRVia>S~4V^_AqI{hwcrt0n7cBDUSMQC`$+x}RsO?qbi;COl@T z9wADGrV9?E@OS8G`h3N;1;vlW zAXMz;WeHRVoINm*TPQWhQvB$-ojiB__EmmtIMR_9M##~$Z3!*c`>~QDj1#Wogg>>o zMVY@l2>JrDDCl3(MGP`H=d&xVe_wd`BH2!$9(*6&@EMOLxe0#p2T!AP-dKs6$$7*l zb=^d`e+)b4cC;KQjV^C?NL1*(-@o8?efZ{rw(LL3aJoIYw|)2g(<@#VI`<7?_DGVl zOZD!v>DT<{{7$^o>{U3nlkXX|&r9__fM~uqX(6!A_~rT%-Jp+Sz`vo?iD^L5r2lOr zRsk~S8yFmMcgO7Y{z~5MIX6g^AGv#APuTkLz?_lm|8@axOYH(}Uh8r1gOi3Qrvc!_ z>(_-}Qrp-WF>iHVvs@bX4hs zVo@@?K=sN~9g=U*O{|Xs?Q9!+^>zTY>JrAQS4}|mOF^~on=P~N-uv>kqau`kmy$_S1#-dnasWQGK9 z0fvD}2ws2RbJ*mB8gjV+;K*jb0~r9{CEaDRX}L}nTUWh)Mx3S~0NkP8eV!!o-WCuo z5Xp)Ls}Fu&*MG^PuGI6j2qF&1T9}JB^!3S55jt9(@^CvxFn?LOK#1_%QQmf*pv0+a z{dg^yZeMPkhz)fJ6Iu3oHcvf?l#MvH-I*>{p}#oth_^%=uKhT3r5|kTvkGmu<7apRwx*liLEE11lN~(= zFZrS68vPY4`$;~O2`Kz9%GY9{PZfu-8w;`;AFx)&2*1M11Mj;O8d-|3*

Tcehj@>ej)LcD3B!2E* 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 M50j)cA5+ctACZT57ytkO literal 0 HcmV?d00001 diff --git a/mkdocs/material-overrides/assets/images/moonbeam-foundation-light.webp b/mkdocs/material-overrides/assets/images/moonbeam-foundation-light.webp new file mode 100644 index 0000000000000000000000000000000000000000..61b9699eeee62be0288c2276a3808cf008e7f771 GIT binary patch literal 93790 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 z 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 literal 0 HcmV?d00001 diff --git a/mkdocs/material-overrides/assets/stylesheets/custom.css b/mkdocs/material-overrides/assets/stylesheets/custom.css new file mode 100644 index 00000000..66a3cafd --- /dev/null +++ b/mkdocs/material-overrides/assets/stylesheets/custom.css @@ -0,0 +1,394 @@ +:root { + /* Brand colors */ + --purple-dark: #2b1d3c; + --purple-dark-tint-20: #554a63; + --purple-dark-transparent-15: rgba(140, 132, 245, 0.15); + --purple-dark-transparent-10: rgba(140, 132, 245, 0.1); + --purple-light: #958fdc; + --teal-dark: #06353d; + --teal-dark-transparent-15: rgba(7, 211, 186, 0.15); + --teal-light: #07d3ba; + --teal-light-shade-50: #059482; + --teal-light-transparent-15: rgba(7 211, 186, 0.15); + --pink-dark: #d9254d; + --pink-dark-transparent: rgba(217, 37, 77, 0.75); + --pink-light: #d5b8d3; + --light: #ffffff; + --light-transparent-15: rgba(255, 255, 255, 0.15); + --light-transparent-40: rgba(255, 255, 255, 0.4); + --light-transparent-60: rgba(255, 255, 255, 0.6); + --dark: #000000; + --dark-transparent-60: rgba(0, 0, 0, 0.6); + + /** Material theme overrides **/ + /* Fonts */ + --header-font: 'Banana Grotesk', sans-serif; + --label-font: 'Space Mono', monospace; + + /* Borders */ + --border-width-thin: 0.5px; + --border-width: 1px; + --border-radius: 0.3em; + + /* Link hover opacity */ + --hover-opacity: 0.7; + + /** Admonition */ + --md-admonition-icon--code: url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCI+PHBhdGggZD0iTTE0LjYsMTYuNkwxOS4yLDEyTDE0LjYsNy40TDE2LDZMMjIsMTJMMTYsMThMMTQuNiwxNi42TTkuNCwxNi42TDQuOCwxMkw5LjQsNy40TDgsNkwyLDEyTDgsMThMOS40LDE2LjZaIiAvPjwvc3ZnPg=='); +} + +:root, +[data-md-color-scheme='default'] { + --md-accent-fg-color: var(--teal-light); + + /** Code highlighting color shades **/ + /* Numbers */ + --md-code-hl-number-color: #e1147b; + /* Python function names */ + --md-code-hl-function-color: #42a2a1; + /* JavaScript booleans, Python variable names */ + --md-code-hl-name-color: #9356e9; + /* Strings */ + --md-code-hl-string-color: #e1147b; + /* Python print */ + --md-code-hl-constant-color: #42a2a1; + /* Imports, const, let, var, async, await, function, etc. */ + --md-code-hl-keyword-color: #42a2a1; + /* Comments */ + --md-code-hl-comment-color: #9356e9; + /* Code highlighting */ + --md-code-hl-color: #e1147b; + /* Backslashes */ + --md-code-hl-special-color: #262626; + + /** Footer color */ + --md-footer-bg-color: #ffffff; + --md-footer-bg-color--dark: #ffffff; + --md-footer-fg-color: #000000; + --md-footer-fg-color--light: #000000; + + /** Link color */ + --md-typeset-a-color: var(--teal-light-shade-50); + + /** Badge color */ + --md-typeset-kbd-color: #e9e9e9; + + /** Version dropdown */ + --md-version-bg-color: var(--teal-dark-transparent-15); + + /** Border color */ + --border-color: var(--dark-transparent-60); + --border-grid: var(--border-width-thin) solid var(--border-color); +} + +:root, +[data-md-color-scheme='slate'], +[data-md-color-scheme='slate'][data-md-color-primary='black'] { + --md-default-bg-color: var(--dark); + --md-accent-fg-color: var(--teal-light); + + /** Code highlighting color shades **/ + --md-code-bg-color: var(--purple-dark-transparent-10); + /* Numbers */ + --md-code-hl-number-color: var(--purple-light); + /* Python function names */ + --md-code-hl-function-color: var(--teal-light); + /* JavaScript booleans, Python variable names */ + --md-code-hl-name-color: var(--purple-light); + /* Strings */ + --md-code-hl-string-color: var(--pink-light); + /* Python print */ + --md-code-hl-constant-color: var(--light); + /* Imports, const, let, var, async, await, function, etc. */ + --md-code-hl-keyword-color: var(--teal-light); + /* Comments */ + --md-code-hl-comment-color: var(--light-transparent-60); + /* Code highlighting */ + --md-code-hl-color: var(--pink-dark); + /* Backslashes */ + --md-code-hl-special-color: var(--light); + + /** Footer color */ + --md-footer-fg-color: var(--light); + --md-footer-fg-color--light: var(--light); + --md-footer-bg-color: var(--dark); + --md-footer-bg-color--dark: var(--dark); + + /** Link color */ + --md-typeset-a-color: var(--teal-light-shade-50); + + /** Version dropdown */ + --md-version-bg-color: var(--teal-dark); + + /** Border color */ + --border-color: var(--light-transparent-40); + --border-grid: var(--border-width-thin) solid var(--border-color); +} + +[data-md-color-primary='black'] .md-tabs, +[data-md-color-primary='black'] .md-header { + background-color: var(--dark); +} + +body { + max-width: 97%; + margin: auto; + border-left: var(--border-grid); + border-right: var(--border-grid); +} + +.md-main { + border-top: var(--border-grid); + border-bottom: var(--border-grid); +} + +/* Font size */ +.md-typeset { + font-size: 0.7rem; +} + +.md-nav { + font-size: 0.6rem; +} + +/* Page styling */ +.tutorial { + max-width: 36.8rem; +} + +.md-sidebar__scrollwrap { + margin: 0; + margin-right: 4em; +} + +/* Header styling */ +.md-header__topic:first-child { + font-weight: 400; +} + +.md-social__link { + height: unset; + margin-left: 0.6rem; +} + +.md-social__link svg { + max-height: 1.2rem; + max-width: 1.2rem; +} + +.md-social__link:hover svg { + opacity: var(--hover-opacity); +} + +@media screen and (min-width: 76.25em) { + [dir='ltr'] .md-header__source { + margin-left: 0; + } +} + +[data-md-color-scheme=slate] .md-nav__button.md-logo img[src$="#only-light"], +[data-md-color-scheme='default'] .md-nav__button.md-logo img[src$='#only-dark'], +[data-md-color-scheme=slate] .md-header__button.md-logo img[src$="#only-light"], +[data-md-color-scheme='default'] .md-header__button.md-logo img[src$='#only-dark'] { + display: none; +} + +.md-tabs__link { + font-family: var(--label-font); + text-transform: uppercase; +} + +.md-version__list { + border: var(--border-grid); + border-color: var(--teal-dark); +} + +.md-version__link:focus, +.md-version__link:hover { + color: var(--md-default-fg-color); + background-color: var(--teal-dark-transparent-15); +} + +.md-header--shadow { + box-shadow: unset; + border-bottom: var(--border-grid); +} + +[dir=ltr] .md-search__input::placeholder { + font-family: var(--label-font); + text-transform: uppercase; +} + +.md-header__title--active .md-header__topic+.md-header__topic, +.md-header__topic+.md-header__topic { + transition: none; +} + +/* Footer styling */ +.md-footer-meta__inner { + gap: 1em; +} + +.md-footer-meta__inner .logo { + align-content: center; +} + +.md-footer-copyright { + padding: 0.1em; + margin: auto; + font-size: 0.54rem; + font-family: var(--label-font); + text-transform: uppercase; +} + +.column { + display: flex; + flex-direction: column; + margin: 0.5em; +} + +.moonbeam-foundation-logo { + padding: 1em; + vertical-align: middle; +} + +@media screen and (max-width: 35.2em) { + .md-footer-meta__inner { + justify-content: center; + gap: 0; + } + + .md-footer-copyright { + text-align: center; + } +} + + +/* Reference page styling */ +/* Grid styling */ +.grid>div:last-child { + max-height: 1000px; + overflow: auto; +} + +.md-typeset .grid { + grid-gap: 3rem; +} + +.md-typeset .grid>div:first-child>p:first-child { + margin-top: 0; +} + +.grid .highlight span.filename { + margin-top: 0; +} + +/* Type styling */ +.md-typeset kbd { + border-radius: 1em; + vertical-align: baseline; + box-shadow: none; +} + +/* For links to definitions on reference pages */ +.md-typeset .twemoji { + vertical-align: middle; +} + +/* Add arrows to left navigation sections */ +@media screen and (min-width: 76.25em) { + + .md-nav__item--active .md-nav__link[href='../interfaces/'] .md-ellipsis:after, + .md-nav__item--active .md-nav__link[href='../methods/'] .md-ellipsis:after { + background-color: currentcolor; + content: ''; + display: inline-block; + -webkit-mask-position: center; + mask-position: center; + -webkit-mask-repeat: no-repeat; + mask-repeat: no-repeat; + -webkit-mask-size: contain; + mask-size: contain; + mask-image: url('data:image/svg+xml;charset=utf-8,'); + /* Unicode character for a downward-pointing triangle */ + -webkit-mask-image: url('data:image/svg+xml;charset=utf-8,'); + /* Unicode character for a downward-pointing triangle */ + transition: transform 0.25s; + height: 24px; + width: 24px; + vertical-align: middle; + } + + .md-nav__item--active .md-nav__link.md-nav__link--active[href='./'] .md-ellipsis:after { + transform: rotate(90deg); + background-color: currentcolor; + content: ''; + display: inline-block; + -webkit-mask-position: center; + mask-position: center; + -webkit-mask-repeat: no-repeat; + mask-repeat: no-repeat; + -webkit-mask-size: contain; + mask-size: contain; + mask-image: url('data:image/svg+xml;charset=utf-8,'); + /* Unicode character for a downward-pointing triangle */ + -webkit-mask-image: url('data:image/svg+xml;charset=utf-8,'); + /* Unicode character for a downward-pointing triangle */ + transition: transform 0.25s; + height: 24px; + width: 24px; + vertical-align: middle; + } + + [dir='ltr'] .md-nav--integrated>.md-nav__list>.md-nav__item--active .md-nav--secondary { + border-left: 0.05rem solid var(--md-default-fg-color--lightest); + } + + [dir='ltr'] .md-sidebar--primary:not([hidden])~.md-content>.md-content__inner { + margin-left: 0; + margin-right: 0; + } +} + +/* Disclaimer styling */ +.page-disclaimer { + font-size: x-small; + font-style: italic; + margin-top: 3em; +} + +/* Admonition styling */ +.md-typeset details.note, +.md-typeset .admonition.note { + border-color: var(--teal-light-shade-50); +} + +.md-typeset .note>.admonition-title { + background-color: var(--teal-dark-transparent-15); +} + +.md-typeset .note>.admonition-title:before { + background-color: var(--teal-light-shade-50); +} + +.md-typeset details.code, +.md-typeset .admonition.code { + border-color: var(--purple-light); +} + +.md-typeset .code>.admonition-title, +.md-typeset .code>summary { + background-color: var(--purple-dark-transparent-15); +} + +.md-typeset .code>.admonition-title::before, +.md-typeset .code>summary::before { + background-color: var(--purple-light); + -webkit-mask-image: var(--md-admonition-icon--code); + mask-image: var(--md-admonition-icon--code); +} + +/* Tab styling */ +.js .md-typeset .tabbed-labels:before { + background-color: var(--purple-light); +} \ No newline at end of file diff --git a/mkdocs/material-overrides/assets/stylesheets/fonts/BananaGrotesk-Regular.otf b/mkdocs/material-overrides/assets/stylesheets/fonts/BananaGrotesk-Regular.otf new file mode 100644 index 0000000000000000000000000000000000000000..12afc2ddf320c331f477a8f1c5fba90e74c2cb02 GIT binary patch literal 42268 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 X9LW^^6rW#QdY;Fhj#@*$kWu_Ux~B_g literal 0 HcmV?d00001 diff --git a/mkdocs/material-overrides/assets/stylesheets/home.css b/mkdocs/material-overrides/assets/stylesheets/home.css new file mode 100644 index 00000000..3dcd6e7c --- /dev/null +++ b/mkdocs/material-overrides/assets/stylesheets/home.css @@ -0,0 +1,136 @@ +/* Background image on home page */ +[data-md-color-scheme='slate'] .md-main { + /* Set gradient background */ + background: linear-gradient(#000, #291E3A); + /* For older browsers */ + background: -webkit-linear-gradient(#000, #291E3A); + background: -moz-linear-gradient(#000, #291E3A); + background: -o-linear-gradient(#000, #291E3A); +} + +/* Background image on home page */ +[data-md-color-scheme='default'] .md-main { + /* Set gradient background */ + background: linear-gradient(#958fdc, #fff); + /* For older browsers */ + background: -webkit-linear-gradient(#958fdc, #fff); + background: -moz-linear-gradient(#958fdc, #fff); + background: -o-linear-gradient(#958fdc, #fff); +} + +/* Styles for the hero section */ +.hero { + text-align: center; + padding: 10px 0; + color: var(--md-default-fg-color); +} + +.hero-content { + width: fit-content; + max-width: 800px; + margin: 0 auto; + padding: 0 3em; + background: var(--md-home-hero-bg-color); +} + +.hero h1 { + font-size: 36px; + color: var(--md-default-fg-color); +} + +.hero p { + font-size: 18px; + margin-top: 20px; +} + +.md-typeset .hero-content hr { + border-color: #958fdc; + width: 70%; + margin: auto; +} + +.hero p.note { + font-size: 15px; +} + +/* Styles for the featured content section */ +.featured-content { + display: flex; + flex-wrap: wrap; + justify-content: space-between; +} + +.feature { + text-align: center; + padding: 20px; + box-shadow: 0px 0px 1px var(--md-default-fg-color); + border-radius: var(--border-radius); + width: 30%; + margin: 1em; +} + +.feature a { + margin-top: auto; +} + +.feature img { + width: 60px; + max-width: 100%; + height: auto; +} + +.feature h2 { + font-size: 24px; + margin-top: 10px; + margin-bottom: 10px; + color: var(--md-default-fg-color); +} + +.feature p { + font-size: 16px; + color: var(--md-default-fg-color); +} + +.md-clipboard { + top: 2em; +} + +.install { + margin: auto; + display: flex; + justify-content: center; +} + +.md-typeset pre>code { + display: flex; + height: 4em; + padding: 0; +} + +.md-typeset pre { + margin: 0; +} + +@media screen and (max-width: 76.234375em) { + .code { + display: none + } +} + +@media screen and (max-width: 56em) { + .feature { + width: 46%; + } +} + +@media screen and (max-width: 45.125em) { + .feature { + width: 100%; + } +} + +@media screen and (max-width: 38.125em) { + .feature { + width: 100%; + } +} \ No newline at end of file diff --git a/mkdocs/material-overrides/home.html b/mkdocs/material-overrides/home.html new file mode 100644 index 00000000..27538579 --- /dev/null +++ b/mkdocs/material-overrides/home.html @@ -0,0 +1,49 @@ +{% extends "main.html" %} + +{% block htmltitle %} +XCM SDK Docs +{% endblock %} + +{% block styles %} +{{ super() }} + +{% endblock %} + +{% block content %} +

+
+
+

Documentation for the XCM SDK

+

Dive into our comprehensive XCM SDK documentation to streamline your development journey, enabling you to + effortlessly integrate cross-chain functionality into your projects within the Polkadot ecosystem.

+
+ 
+            
+              npm install @moonbeam-foundation/xcm-sdk
+            
+
+
+
+
+
+ + Feature 1 +

SDK Reference

+

Explore the comprehensive array of interfaces and methods designed for facilitating XCM transfers across chains + within the Polkadot and Kusama ecosystems.

+ + + Feature 2 +

Get Coding

+

Dive in and start coding with our guide on using the SDK to transfer assets seamlessly between parachains or + from a parachain to the relay chain.

+ + + Feature 3 +

Contribute

+

Seeking to enhance the SDK's capabilities with support for a new chain or asset? Uncover the process for + contributing to the SDK.

+ +
+
+{% endblock %} \ No newline at end of file diff --git a/mkdocs/material-overrides/main.html b/mkdocs/material-overrides/main.html new file mode 100644 index 00000000..718241bf --- /dev/null +++ b/mkdocs/material-overrides/main.html @@ -0,0 +1,11 @@ +{#- +This file was automatically generated - do not edit +-#} + +{% extends "base.html" %} + +{% block fonts %} +{{ super() }} + + +{% endblock %} \ No newline at end of file diff --git a/mkdocs/material-overrides/partials/footer.html b/mkdocs/material-overrides/partials/footer.html new file mode 100644 index 00000000..eda0da0d --- /dev/null +++ b/mkdocs/material-overrides/partials/footer.html @@ -0,0 +1,28 @@ +
+
+
+ +
+
+ {% if config.copyright %} +
+ Made with 💜 by the Moonbeam team. +
+
+ {{ config.copyright }} +
+
+ Privacy policy + | + Terms of use +
+ {% endif %} +
+
+
+
\ No newline at end of file diff --git a/mkdocs/material-overrides/partials/header.html b/mkdocs/material-overrides/partials/header.html new file mode 100644 index 00000000..37107431 --- /dev/null +++ b/mkdocs/material-overrides/partials/header.html @@ -0,0 +1,64 @@ +{#- +This file was automatically generated - do not edit +-#} +{% set class = "md-header" %} +{% if "navigation.tabs.sticky" in features %} +{% set class = class ~ " md-header--shadow md-header--lifted" %} +{% elif "navigation.tabs" not in features %} +{% set class = class ~ " md-header--shadow" %} +{% endif %} +
+ + {% if "navigation.tabs.sticky" in features %} + {% if "navigation.tabs" in features %} + {% include "partials/tabs.html" %} + {% endif %} + {% endif %} +
\ No newline at end of file diff --git a/mkdocs/material-overrides/partials/logo.html b/mkdocs/material-overrides/partials/logo.html new file mode 100644 index 00000000..96fc1183 --- /dev/null +++ b/mkdocs/material-overrides/partials/logo.html @@ -0,0 +1,10 @@ +{#- +This file was automatically generated - do not edit +-#} +{% if config.theme.logo %} + logo + logo +{% else %} + {% set icon = config.theme.icon.logo or "material/library" %} + {% include ".icons/" ~ icon ~ ".svg" %} +{% endif %} \ No newline at end of file diff --git a/mkdocs/material-overrides/tutorial.html b/mkdocs/material-overrides/tutorial.html new file mode 100644 index 00000000..402a4dac --- /dev/null +++ b/mkdocs/material-overrides/tutorial.html @@ -0,0 +1,7 @@ +{% extends "main.html" %} + +{% block content %} +
+ {{ super() }} +
+{% endblock %} diff --git a/mkdocs/mkdocs.yml b/mkdocs/mkdocs.yml new file mode 100644 index 00000000..c1027ee0 --- /dev/null +++ b/mkdocs/mkdocs.yml @@ -0,0 +1,72 @@ +site_name: XCM SDK Docs +site_url: https://moonbeam-foundation.github.io/xcm-sdk/ +docs_dir: docs +copyright: © 2024 Moonbeam Foundation. All Rights Reserved. +repo_name: moonbeam-foundation/xcm-sdk +repo_url: https://github.com/moonbeam-foundation/xcm-sdk +theme: + name: material + custom_dir: material-overrides + favicon: assets/images/logo.webp + logo: assets/images/logo.webp + logo_dark_mode: assets/images/logo-dark.webp + icon: + repo: fontawesome/brands/github + font: + text: Banana Grotesk + palette: + # Palette toggle for light mode + - media: '(prefers-color-scheme: light)' + scheme: default + primary: white + toggle: + icon: material/weather-night + name: Switch to dark mode + # Palette toggle for dark mode + - media: '(prefers-color-scheme: dark)' + scheme: slate + primary: black + toggle: + icon: material/weather-sunny + name: Switch to light mode + features: + - content.code.copy + - navigation.indexes + - navigation.tabs + - toc.follow + - toc.integrate +extra_css: + - assets/stylesheets/custom.css +plugins: + - search + - awesome-pages + - mike: + canonical_version: latest +markdown_extensions: + - admonition + - attr_list + - md_in_html + - pymdownx.details + - pymdownx.emoji: + emoji_index: !!python/name:material.extensions.emoji.twemoji + emoji_generator: !!python/name:material.extensions.emoji.to_svg + - pymdownx.highlight: + anchor_linenums: true + line_spans: __span + pygments_lang_class: true + - pymdownx.inlinehilite + - pymdownx.keys + - pymdownx.snippets: + base_path: docs/.snippets + - pymdownx.superfences + - pymdownx.tabbed: + alternate_style: true +extra: + generator: false + version: + provider: mike + social: + - icon: fontawesome/brands/discord + link: https://discord.gg/PfpUATX + name: Discord + diff --git a/mkdocs/requirements.txt b/mkdocs/requirements.txt new file mode 100644 index 00000000..61cdb579 --- /dev/null +++ b/mkdocs/requirements.txt @@ -0,0 +1,6 @@ +mkdocs==1.5.3 +mkdocs-awesome-pages-plugin==2.9.2 +mkdocs-git-revision-date-localized-plugin==1.2.2 +mkdocs-material==9.5.3 +mkdocs-redirects==1.2.1 +mike==2.0.0 \ No newline at end of file diff --git a/packages/sdk/README.md b/packages/sdk/README.md index a4b153f8..f462d939 100644 --- a/packages/sdk/README.md +++ b/packages/sdk/README.md @@ -4,17 +4,7 @@ The XCM SDK offers helper functions, that provide a very simple interface to exe # Documentation -## v2 (current) - -- [readme](https://github.com/moonbeam-foundation/xcm-sdk/tree/main) -- [usage](https://docs.moonbeam.network/builders/interoperability/xcm/xcm-sdk/v1/xcm-sdk/) (Updated docs coming soon...) -- [reference](https://docs.moonbeam.network/builders/interoperability/xcm/xcm-sdk/v1/reference/) (Updated docs coming soon...) - -## v1 (previous) - -- [readme](https://github.com/moonbeam-foundation/xcm-sdk/tree/v1) -- [usage](https://docs.moonbeam.network/builders/interoperability/xcm/xcm-sdk/v1/xcm-sdk/) -- [reference](https://docs.moonbeam.network/builders/interoperability/xcm/xcm-sdk/v1/reference/) +You can find the documentation at [https://moonbeam-foundation.github.io/xcm-sdk-mkdocs/latest/reference/interfaces/](https://moonbeam-foundation.github.io/xcm-sdk-mkdocs/latest/reference/interfaces/). # Installation