Skip to main content

Get FAssets Lot Size (Node)

Overview​

In this guide, you will build a TypeScript script that connects to the Songbird Testnet Coston and:

This guide is a perfect first step for developers working with FAssets.

Prerequisites​

Project Setup​

Create Project Directory​

Create a new directory for your project and initialize a new npm project:

mkdir fassets-settings-ftso
cd fassets-settings-ftso
npm init -y

Install Dependencies​

Install the following dependencies:

npm install --save-dev \
  typescript \
  typechain \
  ethers \
  @typechain/ethers-v6 \
  @flarenetwork/flare-periphery-contract-artifacts

Configure TypeScript​

Create a config file `tsconfig.json to control TypeScript behavior:

npx tsc --init

Change the tsconfig.json file so it can find the Flare generated types:

tsconfig.json
{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "moduleResolution": "node",
    "esModuleInterop": true,
    "strict": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "outDir": "./dist"
  },
  "include": ["scripts/**/*.ts", "typechain/**/*.ts", "typechain/**/*.d.ts"],
  "exclude": ["node_modules"]
}

Update Package Configuration​

For convenience, add the Typescript build and type generation commands to the scripts section of the package.json file:

"scripts": {
  "build": "tsc",
  "generate-types": "typechain --target ethers-v6 --out-dir typechain './node_modules/@flarenetwork/flare-periphery-contract-artifacts/coston/artifacts/contracts/**/*.json'"
}

The build script will compile the TypeScript code.

Using the Coston network artifacts, the typechain generates TypeScript types from the Flare Periphery contracts, which are provided through a package containing the necessary contract artifacts.

Change the package.json file to use the module type to use ES modules and avoid issues with the import statement:

"type": "module",

Generate TypeScript Types​

To generate the TypeScript types, run the following command:

npm run generate-types

It will generate the types TypeScript types in the typechain directory.

Implementation​

Create Script File​

First, you must create a file to write the TypeScript code for this guide.

mkdir scripts
touch scripts/fassets-settings.ts

Open the scripts/fassets-settings.ts file in your favorite code editor.

Import Dependencies​

Import the ethers library to interact with the blockchain:

import { ethers } from "ethers";

You need to import the FAssets asset manager contract factory type:

import { IAssetManager__factory } from "../typechain/factories/IAssetManager__factory.js";

Define Constants​

Define two constants:

  • COSTON_RPC_URL: The RPC URL for the Coston network.
  • ASSET_MANAGER_ADDRESS: The address of the FAssets asset manager contract. In this case, it is the XRP asset manager address on the Coston network.
const COSTON_RPC = "https://coston-api.flare.network/ext/C/rpc";
const ASSET_MANAGER_ADDRESS = "0xeEd82b8390880af0b6Cb6Dd398a7E361cc30E8e2";

Implement Settings Retrieval​

Next, you need to create an asynchronous function that will fetch the FAssets configuration settings and call in the script.

Inside the getSettings function, you create a new ethers provider, connect to the Coston network, and connect to the FAssets asset manager contract.

After that, you must fetch the FAssets configuration settings using the getSettings function of the FAssets asset manager contract.

The last step is to get the lot size of FXRP in XRP and print it to the console.

scripts/fassets-settings.ts
async function getSettings() {
  const provider = new ethers.JsonRpcProvider(COSTON_RPC);
  const assetManager = IAssetManager__factory.connect(
    ASSET_MANAGER_ADDRESS,
    provider,
  );

  const settings = await assetManager.getSettings();
  const lotSizeFXRP =
    Number(settings.lotSizeAMG) / Math.pow(10, Number(settings.assetDecimals));
  console.log("Lot Size (FXRP):", lotSizeFXRP);
}

getSettings();
info

The getSettings function returns the complete asset manager settings that you can find in the FAssets Operational Parameters documentation.

Convert Lot Size to USD​

To convert the lot size to USD you need to use the FTSO to get the anchor price feed of XRP/USD and convert the FXRP lot size to USD.

Import Dependencies​

Import the IFlareContractRegistry__factory and FtsoV2Interface__factory types which are the factories for the Flare Contract Registry and the FTSO contracts.

import { IFlareContractRegistry__factory } from "../typechain/factories/IFlareContractRegistry__factory.js";
import { FtsoV2Interface__factory } from "../typechain/factories/FtsoV2Interface__factory.js";

Define Constants​

Define the constants for the registry address and the XRP/USD feed ID.

const REGISTRY_ADDRESS = "0xaD67FE66660Fb8dFE9d6b1b4240d8650e30F6019";
const XRP_USD_FEED_ID = "0x015852502f55534400000000000000000000000000";

Get the Price feed XRP/USD​

You can get the price feed XRP/USD by calling the getFeedById function of the FtsoV2 contract.

const registry = IFlareContractRegistry__factory.connect(
  REGISTRY_ADDRESS,
  provider,
);
const ftsoAddress = await registry.getContractAddressByName("FtsoV2");
const ftsoV2 = FtsoV2Interface__factory.connect(ftsoAddress, provider);
const priceFeed = await ftsoV2.getFeedById.staticCall(XRP_USD_FEED_ID);

Convert Lot Size to USD​

Convert the lot size to USD, by multiplying the lot size by the price of XRP in USD.

const xrpUsdPrice = Number(priceFeed[0]) / Math.pow(10, Number(priceFeed[1]));
const lotValueUSD = lotSizeFXRP * xrpUsdPrice;

console.log("XRP/USD Price:", xrpUsdPrice);
console.log("Lot value in USD:", lotValueUSD);
console.log("Timestamp:", priceFeed[2].toString());

Putting All Together​

To put all together you have the following code:

// Importing necessary modules and contract factories
import { ethers } from "ethers";

import { IAssetManager__factory } from "../typechain/factories/IAssetManager__factory.js";
import { IFlareContractRegistry__factory } from "../typechain/factories/IFlareContractRegistry__factory.js";
import { FtsoV2Interface__factory } from "../typechain/factories/FtsoV2Interface__factory.js";

// Constants for RPC endpoint and contract addresses
const COSTON_RPC = "https://coston-api.flare.network/ext/C/rpc"; // RPC URL for the Coston network
const ASSET_MANAGER_ADDRESS = "0xeEd82b8390880af0b6Cb6Dd398a7E361cc30E8e2"; // Address of the Asset Manager contract
const REGISTRY_ADDRESS = "0xaD67FE66660Fb8dFE9d6b1b4240d8650e30F6019"; // Address of the Flare Contract Registry
const XRP_USD_FEED_ID = "0x015852502f55534400000000000000000000000000"; // Feed ID for XRP/USD price https://dev.flare.network/ftso/scaling/anchor-feeds

async function getSettings() {
  // Create a provider for interacting with the blockchain
  const provider = new ethers.JsonRpcProvider(COSTON_RPC);

  // Connect to the Asset Manager contract
  const assetManager = IAssetManager__factory.connect(
    ASSET_MANAGER_ADDRESS,
    provider,
  );

  // Fetch settings from the Asset Manager contract
  const settings = await assetManager.getSettings();

  // Calculate the lot size in FXRP (Flare XRP)
  const lotSizeFXRP =
    Number(settings.lotSizeAMG) / Math.pow(10, Number(settings.assetDecimals));
  console.log("Lot Size (FXRP):", lotSizeFXRP);

  // Connect to the Flare Contract Registry
  const registry = IFlareContractRegistry__factory.connect(
    REGISTRY_ADDRESS,
    provider,
  );

  // Fetch the address of the FtsoV2 contract from the registry
  const ftsoAddress = await registry.getContractAddressByName("FtsoV2");

  // Connect to the FtsoV2 contract
  const ftsoV2 = FtsoV2Interface__factory.connect(ftsoAddress, provider);

  // Fetch the XRP/USD price feed using the feed ID
  const priceFeed = await ftsoV2.getFeedById.staticCall(XRP_USD_FEED_ID);

  // Calculate the XRP/USD price and the lot value in USD
  const xrpUsdPrice = Number(priceFeed[0]) / Math.pow(10, Number(priceFeed[1]));
  const lotValueUSD = lotSizeFXRP * xrpUsdPrice;

  console.log("XRP/USD Price:", xrpUsdPrice);
  console.log("Lot value in USD:", lotValueUSD);
  console.log("Timestamp:", priceFeed[2].toString());
}

getSettings();

Running the Script​

To execute the script, run the following commands to compile the TypeScript code and run the script from the dist directory:

npm run build
node dist/scripts/fassets-settings.js

You should see the following output:

Lot Size (FXRP): 20
XRP/USD Price: 2.1346
Lot value in USD: 42.69199999999999
Timestamp: 1743513507

Congratulations! You have built a TypeScript script that connects to the Coston network and retrieves the FAsset configuration settings and the price of XRP in USD.

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.