Skip to main content

Get FAssets Lot Size (Solidity)

Overview​

This guide will show you how to fetch FAsset lot size for FXRP using the Solidity smart contract on the Flare network. You will deploy the contract using Hardhat and interact with it via a TypeScript script.

Prerequisites​

Create Smart Contract to Fetch FAsset Lot Size​

To get the FAsset lot size, you can use the following smart contract:

contracts/FAssetsSettings.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

// 1. Import the AssetManager interface
import {IAssetManager} from "@flarenetwork/flare-periphery-contracts/coston/IAssetManager.sol";

// 2. Contract for accessing FAssets settings from the asset manager
contract FAssetsSettings {
    // 3. Connection to the AssetManager contract
    IAssetManager public assetManager;

    // 4. Constructor initializes the contract with the AssetManager contract address
    constructor(address _assetManager) {
        assetManager = IAssetManager(_assetManager);
    }

    // 5. This function gets two important numbers from the asset manager settings:
    // * lotSizeAMG: The smallest amount you can trade (in AMG units)
    // * assetDecimals: How many decimal places the asset uses
    // FAssets Operation Parameters https://dev.flare.network/fassets/operational-parameters
    function getLotSize()
        public
        view
        returns (uint64 lotSizeAMG, uint8 assetDecimals)
    {
        lotSizeAMG = assetManager.getSettings().lotSizeAMG;
        assetDecimals = assetManager.getSettings().assetDecimals;

        return (lotSizeAMG, assetDecimals);
    }
}

Code Breakdown​

  1. Import the interface IAssetManager from the Flare Periphery Contracts package, which provides access to the FAssets system.
  2. Create a contract called FAssetsSettings that will be used to fetch the FAssets settings from the asset manager.
  3. Value assetManager holds the address of the FAssets FXRP asset manager contract. The type IAssetManager comes from the Flare Periphery Contracts package.
  4. The constructor initializes the contract with the AsseFXRP asset managertManager address.
  5. The getLotSize function gets numbers from the FAssets FXRP asset manager settings using the getSettings function returns the complete asset manager settings that you can find in the FAssets Operational Parameters documentation:
    • lotSizeAMG: The smallest amount you can trade (in AMG units)
    • assetDecimals: How many decimal places the FAssets asset uses
Flare Hardhat Starter Kit

Using the Flare Hardhat Starter Kit you can quickly deploy the contract and generate TypeChain bindings for seamless TypeScript integration. It streamlines development by providing a ready-made project structure, preconfigured networks, and needed packages.

Deploy and Interact with the Smart Contract​

Use the following TypeScript script to deploy the contract and fetch the FAsset settings using the Hardhat tool:

scripts/fassets/getLotSize.ts
import { ethers } from "hardhat";
import { FAssetsSettingsContract } from "../../typechain-types";

// 1. AssetManager address on Songbird Testnet Coston network
const ASSET_MANAGER_ADDRESS = "0x56728e46908fB6FcC5BCD2cc0c0F9BB91C3e4D34";

async function main() {
  console.log("Deploying FAssetsSettings...");

  // 2.  Get the contract factory
  const FAssetsSettings = (await ethers.getContractFactory(
    "FAssetsSettings",
  )) as FAssetsSettingsContract;

  // 3. Deploy the contract
  const fAssetsSettings = await FAssetsSettings.deploy(ASSET_MANAGER_ADDRESS);
  await fAssetsSettings.waitForDeployment();
  console.log(
    "FAssetsSettings deployed to:",
    await fAssetsSettings.getAddress(),
  );

  // 4. Call getSettings function
  const lotSize = await fAssetsSettings.getLotSize();
  console.log("Lot size:", lotSize[0]);
  console.log("Decimals:", lotSize[1]);

  // 5. Convert lot size to XRP
  const lotSizeFXRP = Number(lotSize[0]) / Math.pow(10, Number(lotSize[1]));
  console.log("Lot size in XRP", lotSizeFXRP);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Code Explanation​

  1. Define the FAssets TXRP asset manager address on the Songbird Testnet Coston network.
  2. Use the Typescript smart contract FAssetsSettings type to interact with the contract.
  3. Deploy the FAssetsSettings on the network and get the contract address.
  4. Call the getLotSize function to get the lot size and asset decimals.
  5. Convert the lot size to XRP.

Run the Script​

Now you can run the script using the Hardhat tool with the following command:

npx hardhat run scripts/fassets/getLotSize.ts --network coston

You should see the following output:

Compiled 1 Solidity file successfully (evm target: london).
Deploying FAssetsSettings...
FAssetsSettings deployed to: 0x40deEaA76224Ca9439D4e1c86F827Be829b89D9E
Lot size: 20000000n
Decimals: 6n
Lot size in XRP 20
info

This script is included in the Flare Hardhat Starter Kit.

Congratulations! You have now deployed a Solidity helper contract and used a TypeScript script to

  • fetch FAsset FXRP lot size and decimals;
  • convert the value to a user-friendly format using decimal precision.
Exploring Additional Parameters

The FAssets asset manager exposes key parameters like collateral ratios, minting fees, and liquidation thresholds via the getSettings() function. See the FAssets Operational Parameters for details.