Assets Pallet

[Victor-Salomon]

Asset Pallet

This document specifies the design choices took for the Assets pallet implementation in the SDK. This pallet will not be fully covered in the SDK, and only a few specific features will be implemented depending of our needs.

Feel free to comment on certain misunderstandings and new suggestions are warm welcomed.

Sections:

• Events: list of the incoming events from the chain. (1 events)
• Extrinsics: SDK extrinsics to implement on the SDK. (1 helpers)
• Storage: SDK storage to implement on the SDK. (1 getters)

Events

In order to make the returned event datas usefull, we provide both the native format and a friendly ready to use format design format :

• a string as an AccountId32 correspond to a classic user valid address.
• a string as u128 is a BN value as string natively used under the hood by the chain.
• a rounded data (ex: amoutRounded) is the "human" version of a data, (usually a BN) that can be directly used.

We need 1 event triggered by the chain from the Assets module.

/// Assets Transferred. Some assets were transferred. [asset_id, from, to, amount]
Transferred(T::AssetId, T::AccountId, T::AccountId, T::Balance), 

SDK events

cf : https://docs.rs/pallet-assets/latest/pallet_assets/pallet/enum.Event.html#variant.Transferred

Additional events will be added to the EventType enum in src > events.ts in the SDK:

export enum EventType {
  ...
	 // Asset
  AssetTransferred = "assets.Transferred",
}

static fromEvent(event: Event): BlockchainEvent {
    ...
    
    switch (name) {
      ...
      // Assets
      case EventType.AssetTransferred:
        return new AssetTransferredEvent(event)
    }
    ...
  }
}

/**
 * This class represents the on-chain AssetTransferredEvent event.
 */
export class AssetTransferredEvent extends BlockchainEvent {
  assetId: number
  from: string // AccountId32 
  to: string // AccountId32 
  amount: string
  amountRounded : number

  /**
   * Construct the data object from the AssetTransferredEvent event
   * @param event The AssetTransferredEvent event
   */
  constructor(event: Event) {
    super(event, EventType.AssetTransferred)
    const [
      assetId,
      from,
      to,
      amount,
    ] = event.data

  this.assetId= Number.parseInt(assetId.toString())
  this.from=from.toString()
  this.to= to.toString() 
  this.amount= bnToBn(amount.toString()).toString()
  this.amountRounded = roundBalance(this.amount)
 }
}

Extrinsics

1 extrinsics will be implemented from the Assets pallet.

Each helperTx will be duplicated by another helper version with 2 additional parameters: the keyring that will be used to sign and submit the transaction, and a waitUntil callback parameter, to define at which point we want to get the results of the transaction execution.

/**
 * @name assetTransferTx
 * @summary           Creates an unsigned unsubmitted Assets-Transfert Transaction Hash.
 * @param id            ID of the Asset
 * @param target            Public address of the account to transfer the amount to.
 * @param amount            Token amount to transfer.
 * @returns            Unsigned unsubmitted Assets-Transfert Transaction Hash. The Hash is only valid for 5 minutes.
 */
export const assetTransferTx = async (id: string, target: string, amount: number | BN): Promise<TransactionHashType> => {
  const transferredAmount = typeof amount === "number" ? await numberToBalance(amount) : amount
  return await createTxHex(txPallets.assets, txActions.transfer, [to, target, transferredAmount])
}

/**
 * @name assetTransfer
 * @summary             Transfers some balance to another account.
 * @param id            ID of the Asset
 * @param target            Public address of the account to transfer the amount to.
 * @param amount            Token amount to transfer.
 * @param keyring       Account that will sign the transaction.
 * @param waitUntil     Execution trigger that can be set either to BlockInclusion or BlockFinalization.
 * @returns             AssetTransferredEvent Blockchain event.
 */
export const assetTransfer = async (
  id: string, 
  target: string, 
  amount: number | BN
  keyring: IKeyringPair,
  waitUntil: WaitUntil,
): Promise<AssetTransferredEvent> => {
  const tx = await assetTransferTx(id, target, amount)
  const events = await submitTxBlocking(tx, waitUntil, keyring)
  return events.findEventOrThrow(AssetTransferredEvent)
}

Storage

cf : https://docs.rs/pallet-assets/latest/pallet_assets/pallet/struct.Pallet.html#method.balance

1 storage getters will be implemented for the Assets pallet.

balance(id: T:AssetId, who: T::AccountId) -> T::Balance
//Get the asset id balance of who.

export enum txPallets {
  ...
  assets = "assets",
}

export enum chainQuery {
  ...
  // assets
  balance = "balance"
  account="account"
}

/**
 * @name getAssetBalance
 * @summary       Get the balances of an account for a specific asset.
 * @param assetId   The ID of the asset.
 * @param AccountId   Public address of the account to get balances.
 * @returns           The balances of the account.
 */
getAssetBalance(
    assetId: number,
    AccountId: string,
): Promise<BalanceType> => query(txPallets.assets, chainQuery.account, [assetId, AccountId])