@alephium/web3 1.0.2-rc.2 → 1.0.2

package/src/api/api-explorer.ts

@@ -9,57 +9,40 @@
  * ---------------------------------------------------------------
  */
 
-/** Val */
-export type Val = ValAddress | ValArray | ValBool | ValByteVec | ValI256 | ValU256
-
-/** ContractOutput */
-export interface ContractOutput {
-  /** @format address */
-  address: string
-  /** @format int32 */
-  hint: number
+export interface AcceptedTransaction {
   /** @format 32-byte-hash */
-  spent?: string
+  hash: string
+  /** @format block-hash */
+  blockHash: string
+  /** @format int64 */
+  timestamp: number
+  inputs?: Input[]
+  outputs?: Output[]
+  /** @format int32 */
+  gasAmount: number
   /** @format uint256 */
-  attoAlphAmount: string
-  tokens?: Token[]
-  fixedOutput: boolean
+  gasPrice: string
+  scriptExecutionOk: boolean
+  coinbase: boolean
   type: string
-  /** @format 32-byte-hash */
-  key: string
-}
-
-/** IntervalType */
-export enum IntervalType {
-  Daily = 'daily',
-  Hourly = 'hourly',
-  Weekly = 'weekly'
 }
 
-/** Token */
-export interface Token {
+export interface AddressBalance {
   /** @format uint256 */
-  amount: string
-  /** @format 32-byte-hash */
-  id: string
-}
-
-/** ContractLivenessLocation */
-export interface ContractLivenessLocation {
-  /** @format block-hash */
-  blockHash: string
-  /** @format 32-byte-hash */
-  txHash: string
-  /** @format int64 */
-  timestamp: number
+  balance: string
+  /** @format uint256 */
+  lockedBalance: string
 }
 
-/** NonStandard */
-export interface NonStandard {
-  type: string
+export interface AddressInfo {
+  /** @format uint256 */
+  balance: string
+  /** @format uint256 */
+  lockedBalance: string
+  /** @format int32 */
+  txNumber: number
 }
 
-/** AddressTokenBalance */
 export interface AddressTokenBalance {
   /** @format 32-byte-hash */
   tokenId: string
@@ -69,532 +52,421 @@ export interface AddressTokenBalance {
   lockedBalance: string
 }
 
-/** OutputRef */
-export interface OutputRef {
+export interface AmountHistory {
+  amountHistory?: TimedAmount[]
+}
+
+export interface AssetOutput {
   /** @format int32 */
   hint: number
   /** @format 32-byte-hash */
   key: string
-}
-
-/** Input */
-export interface Input {
-  /** @format address */
-  address?: string
-  contractInput: boolean
-  /** @format hex-string */
-  unlockScript?: string
   /** @format uint256 */
-  attoAlphAmount?: string
+  attoAlphAmount: string
+  /** @format address */
+  address: string
   tokens?: Token[]
-  /** @format 32-byte-hash */
-  txHashRef?: string
-  outputRef: OutputRef
-}
-
-/** PerChainCount */
-export interface PerChainCount {
-  /** @format int32 */
-  chainFrom: number
-  /** @format int32 */
-  chainTo: number
   /** @format int64 */
-  count: number
+  lockTime?: number
+  /** @format hex-string */
+  message?: string
+  /** @format 32-byte-hash */
+  spent?: string
+  type: string
 }
 
-/** Unknown */
-export interface Unknown {
-  id: string
-  type: string
+export interface BadRequest {
+  detail: string
 }
 
-/** BlockEntry */
-export interface BlockEntry {
+export interface BlockEntryLite {
   /** @format block-hash */
-  parent?: string
+  hash: string
+  /** @format int64 */
+  timestamp: number
   /** @format group-index */
   chainFrom: number
-  /** @format 32-byte-hash */
-  depStateHash: string
-  deps?: string[]
-  /** @format hex-string */
-  nonce: string
-  version: number
-  /** @format hex-string */
-  target: string
-  mainChain: boolean
-  /** @format 32-byte-hash */
-  txsHash: string
   /** @format group-index */
   chainTo: number
-  ghostUncles?: GhostUncle[]
-  /** @format bigint */
-  hashRate: string
-  /** @format int32 */
-  txNumber: number
-  /** @format block-hash */
-  hash: string
   /** @format int32 */
   height: number
-  /** @format int64 */
-  timestamp: number
-}
-
-/** ContractParent */
-export interface ContractParent {
-  /** @format address */
-  parent?: string
-}
-
-/** ServiceUnavailable */
-export interface ServiceUnavailable {
-  detail: string
-}
-
-/** ValI256 */
-export interface ValI256 {
-  type: string
+  /** @format int32 */
+  txNumber: number
+  mainChain: boolean
   /** @format bigint */
-  value: string
+  hashRate: string
 }
 
-/** ContractLiveness */
 export interface ContractLiveness {
   /** @format address */
   parent?: string
-  interfaceId?: StdInterfaceId
-  destruction?: ContractLivenessLocation
   creation: ContractLivenessLocation
+  destruction?: ContractLivenessLocation
+  interfaceId?: StdInterfaceId
 }
 
-/** AssetOutput */
-export interface AssetOutput {
-  /** @format address */
-  address: string
+export interface ContractLivenessLocation {
+  /** @format block-hash */
+  blockHash: string
+  /** @format 32-byte-hash */
+  txHash: string
   /** @format int64 */
-  lockTime?: number
+  timestamp: number
+}
+
+export interface ContractOutput {
   /** @format int32 */
   hint: number
   /** @format 32-byte-hash */
-  spent?: string
+  key: string
   /** @format uint256 */
   attoAlphAmount: string
+  /** @format address */
+  address: string
   tokens?: Token[]
-  fixedOutput: boolean
-  type: string
-  /** @format hex-string */
-  message?: string
   /** @format 32-byte-hash */
-  key: string
+  spent?: string
+  type: string
 }
 
-/** NFT */
-export interface NFT {
-  type: string
+export interface ContractParent {
+  /** @format address */
+  parent?: string
 }
 
-/** AcceptedTransaction */
-export interface AcceptedTransaction {
-  outputs?: Output[]
+export interface Event {
   /** @format block-hash */
   blockHash: string
-  scriptSignatures?: string[]
-  inputs?: Input[]
-  scriptExecutionOk: boolean
-  type: string
-  scriptOpt?: string
-  version: number
-  coinbase: boolean
-  inputSignatures?: string[]
-  /** @format int32 */
-  gasAmount: number
-  networkId: number
   /** @format 32-byte-hash */
-  hash: string
-  /** @format uint256 */
-  gasPrice: string
+  txHash: string
+  /** @format address */
+  contractAddress: string
+  /** @format address */
+  inputAddress?: string
+  /** @format int32 */
+  eventIndex: number
+  fields?: Val[]
+}
+
+export interface ExplorerInfo {
+  releaseVersion: string
+  commit: string
+  /** @format int32 */
+  migrationsVersion: number
   /** @format int64 */
-  timestamp: number
+  lastFinalizedInputTime: number
 }
 
-/** TokenSupply */
-export interface TokenSupply {
-  /** @format uint256 */
-  circulating: string
-  /** @format uint256 */
-  total: string
-  /** @format uint256 */
-  reserved: string
-  /** @format uint256 */
-  maximum: string
+export interface FungibleToken {
+  type: string
+}
+
+export interface FungibleTokenMetadata {
+  /** @format 32-byte-hash */
+  id: string
+  symbol: string
+  name: string
   /** @format uint256 */
-  locked: string
+  decimals: string
+}
+
+export interface Hashrate {
   /** @format int64 */
   timestamp: number
+  hashrate: number
+  value: number
 }
 
-/** PendingTransaction */
-export interface PendingTransaction {
-  outputs?: Output[]
-  /** @format group-index */
-  chainFrom: number
-  /** @format int64 */
-  lastSeen: number
-  /** @format group-index */
-  chainTo: number
-  inputs?: Input[]
-  /** @format int32 */
-  gasAmount: number
-  type: string
+export interface Input {
+  outputRef: OutputRef
+  /** @format hex-string */
+  unlockScript?: string
   /** @format 32-byte-hash */
-  hash: string
+  txHashRef?: string
+  /** @format address */
+  address?: string
   /** @format uint256 */
-  gasPrice: string
+  attoAlphAmount?: string
+  tokens?: Token[]
 }
 
-/** TransactionLike */
-export type TransactionLike = AcceptedTransaction | PendingTransaction
+export interface InternalServerError {
+  detail: string
+}
 
-/** LogbackValue */
-export interface LogbackValue {
-  level: string
-  name: string
+export enum IntervalType {
+  Daily = 'daily',
+  Hourly = 'hourly',
+  Weekly = 'weekly'
 }
 
-/** ValU256 */
-export interface ValU256 {
-  type: string
-  /** @format uint256 */
-  value: string
+export interface ListBlocks {
+  /** @format int32 */
+  total: number
+  blocks?: BlockEntryLite[]
 }
 
-/** BlockEntryLite */
-export interface BlockEntryLite {
-  mainChain: boolean
+export interface LogbackValue {
+  name: string
+  level: string
+}
+
+export interface MempoolTransaction {
+  /** @format 32-byte-hash */
+  hash: string
   /** @format group-index */
   chainFrom: number
   /** @format group-index */
   chainTo: number
-  /** @format bigint */
-  hashRate: string
-  /** @format int32 */
-  txNumber: number
-  /** @format block-hash */
-  hash: string
+  inputs?: Input[]
+  outputs?: Output[]
   /** @format int32 */
-  height: number
+  gasAmount: number
+  /** @format uint256 */
+  gasPrice: string
   /** @format int64 */
-  timestamp: number
+  lastSeen: number
 }
 
-/** PerChainHeight */
-export interface PerChainHeight {
-  /** @format int32 */
-  chainFrom: number
-  /** @format int32 */
-  chainTo: number
-  /** @format int64 */
-  value: number
-  /** @format int64 */
-  height: number
+export interface NFT {
+  type: string
 }
 
-/** ValByteVec */
-export interface ValByteVec {
+export interface NFTCollection {
   type: string
-  /** @format hex-string */
-  value: string
 }
 
-/** TokenStdInterfaceId */
-export enum TokenStdInterfaceId {
-  Fungible = 'fungible',
-  NonFungible = 'non-fungible',
-  NonStandard = 'non-standard'
+export interface NFTCollectionMetadata {
+  /** @format address */
+  address: string
+  collectionUri: string
 }
 
-/** ExplorerInfo */
-export interface ExplorerInfo {
-  releaseVersion: string
-  commit: string
-  /** @format int32 */
-  migrationsVersion: number
-  /** @format int64 */
-  lastFinalizedInputTime: number
+export interface NFTCollectionWithRoyalty {
+  type: string
 }
 
-/** ValArray */
-export interface ValArray {
+export interface NFTMetadata {
+  /** @format 32-byte-hash */
+  id: string
+  tokenUri: string
+  /** @format 32-byte-hash */
+  collectionId: string
+  /** @format uint256 */
+  nftIndex: string
+}
+
+export interface NonStandard {
   type: string
-  value: Val[]
 }
 
-/** BadRequest */
-export interface BadRequest {
+export interface NotFound {
   detail: string
+  resource: string
 }
 
-/** Hashrate */
-export interface Hashrate {
-  hashrate: number
-  value: number
-  /** @format int64 */
-  timestamp: number
+export type Output = AssetOutput | ContractOutput
+
+export interface OutputRef {
+  /** @format int32 */
+  hint: number
+  /** @format 32-byte-hash */
+  key: string
 }
 
-/** Transaction */
-export interface Transaction {
-  outputs?: Output[]
-  /** @format block-hash */
-  blockHash: string
-  scriptSignatures?: string[]
+export interface PendingTransaction {
+  /** @format 32-byte-hash */
+  hash: string
+  /** @format group-index */
+  chainFrom: number
+  /** @format group-index */
+  chainTo: number
   inputs?: Input[]
-  scriptExecutionOk: boolean
-  scriptOpt?: string
-  version: number
-  coinbase: boolean
-  inputSignatures?: string[]
+  outputs?: Output[]
   /** @format int32 */
   gasAmount: number
-  networkId: number
-  /** @format 32-byte-hash */
-  hash: string
   /** @format uint256 */
   gasPrice: string
   /** @format int64 */
-  timestamp: number
+  lastSeen: number
+  type: string
 }
 
-/** FungibleToken */
-export interface FungibleToken {
-  type: string
+export interface PerChainCount {
+  /** @format int32 */
+  chainFrom: number
+  /** @format int32 */
+  chainTo: number
+  /** @format int64 */
+  count: number
 }
 
-/** GhostUncle */
-export interface GhostUncle {
-  /** @format block-hash */
-  blockHash: string
-  /** @format address */
-  miner: string
+export interface PerChainDuration {
+  /** @format int32 */
+  chainFrom: number
+  /** @format int32 */
+  chainTo: number
+  /** @format int64 */
+  duration: number
+  /** @format int64 */
+  value: number
 }
 
-/** NFTCollectionWithRoyalty */
-export interface NFTCollectionWithRoyalty {
-  type: string
+export interface PerChainHeight {
+  /** @format int32 */
+  chainFrom: number
+  /** @format int32 */
+  chainTo: number
+  /** @format int64 */
+  height: number
+  /** @format int64 */
+  value: number
 }
 
-/** PerChainTimedCount */
 export interface PerChainTimedCount {
-  totalCountPerChain?: PerChainCount[]
   /** @format int64 */
   timestamp: number
+  totalCountPerChain?: PerChainCount[]
 }
 
-/** MempoolTransaction */
-export interface MempoolTransaction {
-  outputs?: Output[]
-  /** @format group-index */
-  chainFrom: number
-  /** @format int64 */
-  lastSeen: number
-  /** @format group-index */
-  chainTo: number
-  inputs?: Input[]
-  /** @format int32 */
-  gasAmount: number
-  /** @format 32-byte-hash */
-  hash: string
-  /** @format uint256 */
-  gasPrice: string
+export interface ServiceUnavailable {
+  detail: string
 }
 
-export enum TokensWithPrice {
-  WETH = 'WETH',
-  ALPH = 'ALPH',
-  USDT = 'USDT',
-  AYIN = 'AYIN',
-  DAI = 'DAI',
-  USDC = 'USDC',
-  WBTC = 'WBTC'
+export type StdInterfaceId = FungibleToken | NFT | NFTCollection | NFTCollectionWithRoyalty | NonStandard | Unknown
+
+export interface SubContracts {
+  subContracts?: string[]
 }
 
-export enum MaxSizeTokens {
-  Value80 = 80
+export interface TimedAmount {
+  /** @format int64 */
+  timestamp: number
+  /** @format bigint */
+  amount: string
 }
 
-/** NFTCollection */
-export interface NFTCollection {
-  type: string
+export interface TimedCount {
+  /** @format int64 */
+  timestamp: number
+  /** @format int64 */
+  totalCountAllChains: number
 }
 
-export enum MaxSizeAddressesForTokens {
-  Value80 = 80
+export interface TimedPrices {
+  timestamps?: number[]
+  prices?: number[]
 }
 
-/** InternalServerError */
-export interface InternalServerError {
-  detail: string
+export interface Token {
+  /** @format 32-byte-hash */
+  id: string
+  /** @format uint256 */
+  amount: string
+}
+
+export interface TokenInfo {
+  /** @format 32-byte-hash */
+  token: string
+  /** Raw interface id, e.g. 0001 */
+  stdInterfaceId?: TokenStdInterfaceId | string
 }
 
-/** TimedPrices */
-export interface TimedPrices {
-  timestamps?: number[]
-  prices?: number[]
+export enum TokenStdInterfaceId {
+  Fungible = 'fungible',
+  NonFungible = 'non-fungible',
+  NonStandard = 'non-standard'
 }
 
-/** TimedCount */
-export interface TimedCount {
-  /** @format int64 */
-  totalCountAllChains: number
+export interface TokenSupply {
   /** @format int64 */
   timestamp: number
-}
-
-/** NFTMetadata */
-export interface NFTMetadata {
   /** @format uint256 */
-  nftIndex: string
-  tokenUri: string
-  /** @format 32-byte-hash */
-  id: string
-  /** @format 32-byte-hash */
-  collectionId: string
+  total: string
+  /** @format uint256 */
+  circulating: string
+  /** @format uint256 */
+  reserved: string
+  /** @format uint256 */
+  locked: string
+  /** @format uint256 */
+  maximum: string
 }
 
-/** PerChainDuration */
-export interface PerChainDuration {
+export interface Transaction {
+  /** @format 32-byte-hash */
+  hash: string
+  /** @format block-hash */
+  blockHash: string
   /** @format int64 */
-  duration: number
-  /** @format int32 */
-  chainFrom: number
+  timestamp: number
+  inputs?: Input[]
+  outputs?: Output[]
   /** @format int32 */
-  chainTo: number
-  /** @format int64 */
-  value: number
+  gasAmount: number
+  /** @format uint256 */
+  gasPrice: string
+  scriptExecutionOk: boolean
+  coinbase: boolean
 }
 
-/** StdInterfaceId */
-export type StdInterfaceId = FungibleToken | NFT | NFTCollection | NFTCollectionWithRoyalty | NonStandard | Unknown
-
-/** Output */
-export type Output = AssetOutput | ContractOutput
+export type TransactionLike = AcceptedTransaction | PendingTransaction
 
-/** Unauthorized */
 export interface Unauthorized {
   detail: string
 }
 
-/** NFTCollectionMetadata */
-export interface NFTCollectionMetadata {
-  collectionUri: string
-  /** @format address */
-  address: string
+export interface Unknown {
+  id: string
+  type: string
 }
 
-/** ValAddress */
+export type Val = ValAddress | ValArray | ValBool | ValByteVec | ValI256 | ValU256
+
 export interface ValAddress {
-  type: string
   /** @format address */
   value: string
-}
-
-/** ValBool */
-export interface ValBool {
   type: string
-  value: boolean
 }
 
-/** FungibleTokenMetadata */
-export interface FungibleTokenMetadata {
-  symbol: string
-  /** @format uint256 */
-  decimals: string
-  name: string
-  /** @format 32-byte-hash */
-  id: string
+export interface ValArray {
+  value: Val[]
+  type: string
 }
 
-export enum MaxSizeAddresses {
-  Value80 = 80
+export interface ValBool {
+  value: boolean
+  type: string
 }
 
-export enum Currencies {
-  Btc = 'btc',
-  Eth = 'eth',
-  Usd = 'usd',
-  Eur = 'eur',
-  Chf = 'chf',
-  Gbp = 'gbp',
-  Idr = 'idr',
-  Vnd = 'vnd',
-  Rub = 'rub',
-  Try = 'try',
-  Cad = 'cad',
-  Aud = 'aud'
+export interface ValByteVec {
+  /** @format hex-string */
+  value: string
+  type: string
 }
 
-/** AddressInfo */
-export interface AddressInfo {
-  /** @format uint256 */
-  balance: string
-  /** @format uint256 */
-  lockedBalance: string
-  /** @format int32 */
-  txNumber: number
+export interface ValI256 {
+  /** @format bigint */
+  value: string
+  type: string
 }
 
-/** AddressBalance */
-export interface AddressBalance {
-  /** @format uint256 */
-  balance: string
+export interface ValU256 {
   /** @format uint256 */
-  lockedBalance: string
-}
-
-/** AmountHistory */
-export interface AmountHistory {
-  amountHistory?: string[][]
-}
-
-/** Event */
-export interface Event {
-  /** @format block-hash */
-  blockHash: string
-  /** @format address */
-  inputAddress?: string
-  /** @format address */
-  contractAddress: string
-  /** @format int32 */
-  eventIndex: number
-  fields?: Val[]
-  /** @format 32-byte-hash */
-  txHash: string
-}
-
-/** ListBlocks */
-export interface ListBlocks {
-  /** @format int32 */
-  total: number
-  blocks?: BlockEntryLite[]
+  value: string
+  type: string
 }
 
-/** SubContracts */
-export interface SubContracts {
-  subContracts?: string[]
+export enum MaxSizeTokens {
+  Value80 = 80
 }
 
-/** TokenInfo */
-export interface TokenInfo {
-  /** Raw interface id, e.g. 0001 */
-  stdInterfaceId?: TokenStdInterfaceId | string
-  /** @format 32-byte-hash */
-  token: string
+export enum MaxSizeAddressesForTokens {
+  Value80 = 80
 }
 
-/** NotFound */
-export interface NotFound {
-  resource: string
-  detail: string
+export enum MaxSizeAddresses {
+  Value80 = 80
 }
 
 import 'cross-fetch/polyfill'
@@ -814,35 +686,142 @@ export class HttpClient<SecurityDataType = unknown> {
  * @version 1.0
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
-  contracts = {
+  blocks = {
+    /**
+     * @description List latest blocks
+     *
+     * @tags Blocks
+     * @name GetBlocks
+     * @request GET:/blocks
+     */
+    getBlocks: (
+      query?: {
+        /**
+         * Page number
+         * @format int32
+         */
+        page?: number
+        /**
+         * Number of items per page
+         * @format int32
+         */
+        limit?: number
+        /** Reverse pagination */
+        reverse?: boolean
+      },
+      params: RequestParams = {}
+    ) =>
+      this.request<ListBlocks, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/blocks`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Get a block with hash
+     *
+     * @tags Blocks
+     * @name GetBlocksBlockHash
+     * @request GET:/blocks/{block_hash}
+     */
+    getBlocksBlockHash: (blockHash: string, params: RequestParams = {}) =>
+      this.request<BlockEntryLite, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/blocks/${blockHash}`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Get block's transactions
+     *
+     * @tags Blocks
+     * @name GetBlocksBlockHashTransactions
+     * @request GET:/blocks/{block_hash}/transactions
+     */
+    getBlocksBlockHashTransactions: (
+      blockHash: string,
+      query?: {
+        /**
+         * Page number
+         * @format int32
+         */
+        page?: number
+        /**
+         * Number of items per page
+         * @format int32
+         */
+        limit?: number
+      },
+      params: RequestParams = {}
+    ) =>
+      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/blocks/${blockHash}/transactions`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse)
+  }
+  transactions = {
+    /**
+     * @description Get a transaction with hash
+     *
+     * @tags Transactions
+     * @name GetTransactionsTransactionHash
+     * @request GET:/transactions/{transaction_hash}
+     */
+    getTransactionsTransactionHash: (transactionHash: string, params: RequestParams = {}) =>
+      this.request<TransactionLike, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/transactions/${transactionHash}`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse)
+  }
+  addresses = {
+    /**
+     * @description Get address information
+     *
+     * @tags Addresses
+     * @name GetAddressesAddress
+     * @request GET:/addresses/{address}
+     */
+    getAddressesAddress: (address: string, params: RequestParams = {}) =>
+      this.request<AddressInfo, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
-     * @description Get sub contract addresses
+     * @description List transactions of a given address
      *
-     * @tags Contracts
-     * @name GetContractsContractAddressSubContracts
-     * @request GET:/contracts/{contract_address}/sub-contracts
+     * @tags Addresses
+     * @name GetAddressesAddressTransactions
+     * @request GET:/addresses/{address}/transactions
      */
-    getContractsContractAddressSubContracts: (
-      contractAddress: string,
+    getAddressesAddressTransactions: (
+      address: string,
       query?: {
         /**
          * Page number
          * @format int32
-         * @min 1
          */
         page?: number
         /**
          * Number of items per page
          * @format int32
-         * @min 0
-         * @max 100
          */
         limit?: number
       },
       params: RequestParams = {}
     ) =>
-      this.request<SubContracts, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/contracts/${contractAddress}/sub-contracts`,
+      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/transactions`,
         method: 'GET',
         query: query,
         format: 'json',
@@ -850,47 +829,32 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse),
 
     /**
-     * @description Get contract liveness
-     *
-     * @tags Contracts
-     * @name GetContractsContractAddressCurrentLiveness
-     * @request GET:/contracts/{contract_address}/current-liveness
-     */
-    getContractsContractAddressCurrentLiveness: (contractAddress: string, params: RequestParams = {}) =>
-      this.request<ContractLiveness, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/contracts/${contractAddress}/current-liveness`,
-        method: 'GET',
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse),
-
-    /**
-     * @description Get contract parent address if exist
-     *
-     * @tags Contracts
-     * @name GetContractsContractAddressParent
-     * @request GET:/contracts/{contract_address}/parent
-     */
-    getContractsContractAddressParent: (contractAddress: string, params: RequestParams = {}) =>
-      this.request<ContractParent, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/contracts/${contractAddress}/parent`,
-        method: 'GET',
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse)
-  }
-  addresses = {
-    /**
-     * @description Are the addresses used (at least 1 transaction)
+     * @description List transactions for given addresses
      *
-     * @tags Addresses, Addresses
-     * @name PostAddressesUsed
-     * @request POST:/addresses/used
+     * @tags Addresses
+     * @name PostAddressesTransactions
+     * @request POST:/addresses/transactions
      */
-    postAddressesUsed: (data?: string[], params: RequestParams = {}) =>
-      this.request<boolean[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/used`,
+    postAddressesTransactions: (
+      query?: {
+        /**
+         * Page number
+         * @format int32
+         */
+        page?: number
+        /**
+         * Number of items per page
+         * @format int32
+         */
+        limit?: number
+      },
+      data?: string[],
+      params: RequestParams = {}
+    ) =>
+      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/transactions`,
         method: 'POST',
+        query: query,
         body: data,
         type: ContentType.Json,
         format: 'json',
@@ -898,13 +862,13 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse),
 
     /**
-     * No description
+     * @description List transactions of a given address within a time-range
      *
      * @tags Addresses
-     * @name GetAddressesAddressExportTransactionsCsv
-     * @request GET:/addresses/{address}/export-transactions/csv
+     * @name GetAddressesAddressTimerangedTransactions
+     * @request GET:/addresses/{address}/timeranged-transactions
      */
-    getAddressesAddressExportTransactionsCsv: (
+    getAddressesAddressTimerangedTransactions: (
       address: string,
       query: {
         /**
@@ -917,27 +881,37 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
          * @min 0
          */
         toTs: number
+        /**
+         * Page number
+         * @format int32
+         */
+        page?: number
+        /**
+         * Number of items per page
+         * @format int32
+         */
+        limit?: number
       },
       params: RequestParams = {}
     ) =>
-      this.request<string, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/${address}/export-transactions/csv`,
+      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/timeranged-transactions`,
         method: 'GET',
         query: query,
-        format: 'text',
+        format: 'json',
         ...params
       }).then(convertHttpResponse),
 
     /**
-     * @description Get address balance
+     * @description Get total transactions of a given address
      *
      * @tags Addresses
-     * @name GetAddressesAddressBalance
-     * @request GET:/addresses/{address}/balance
+     * @name GetAddressesAddressTotalTransactions
+     * @request GET:/addresses/{address}/total-transactions
      */
-    getAddressesAddressBalance: (address: string, params: RequestParams = {}) =>
-      this.request<AddressBalance, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/${address}/balance`,
+    getAddressesAddressTotalTransactions: (address: string, params: RequestParams = {}) =>
+      this.request<number, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/total-transactions`,
         method: 'GET',
         format: 'json',
         ...params
@@ -961,35 +935,47 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * @description Get address balance
+     *
+     * @tags Addresses
+     * @name GetAddressesAddressBalance
+     * @request GET:/addresses/{address}/balance
+     */
+    getAddressesAddressBalance: (address: string, params: RequestParams = {}) =>
+      this.request<AddressBalance, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/balance`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description List address tokens
      *
      * @tags Addresses
-     * @name GetAddressesAddressTokensTokenIdTransactions
-     * @request GET:/addresses/{address}/tokens/{token_id}/transactions
+     * @name GetAddressesAddressTokens
+     * @request GET:/addresses/{address}/tokens
+     * @deprecated
      */
-    getAddressesAddressTokensTokenIdTransactions: (
+    getAddressesAddressTokens: (
       address: string,
-      tokenId: string,
       query?: {
         /**
          * Page number
          * @format int32
-         * @min 1
          */
         page?: number
         /**
          * Number of items per page
          * @format int32
-         * @min 0
-         * @max 100
          */
         limit?: number
       },
       params: RequestParams = {}
     ) =>
-      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/${address}/tokens/${tokenId}/transactions`,
+      this.request<string[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/tokens`,
         method: 'GET',
         query: query,
         format: 'json',
@@ -997,58 +983,31 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse),
 
     /**
-     * @description Get total transactions of a given address
-     *
-     * @tags Addresses
-     * @name GetAddressesAddressTotalTransactions
-     * @request GET:/addresses/{address}/total-transactions
-     */
-    getAddressesAddressTotalTransactions: (address: string, params: RequestParams = {}) =>
-      this.request<number, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/${address}/total-transactions`,
-        method: 'GET',
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse),
-
-    /**
-     * @description List transactions of a given address within a time-range
+     * @description List address tokens
      *
      * @tags Addresses
-     * @name GetAddressesAddressTimerangedTransactions
-     * @request GET:/addresses/{address}/timeranged-transactions
+     * @name GetAddressesAddressTokensTokenIdTransactions
+     * @request GET:/addresses/{address}/tokens/{token_id}/transactions
      */
-    getAddressesAddressTimerangedTransactions: (
+    getAddressesAddressTokensTokenIdTransactions: (
       address: string,
-      query: {
-        /**
-         * @format int64
-         * @min 0
-         */
-        fromTs: number
-        /**
-         * @format int64
-         * @min 0
-         */
-        toTs: number
+      tokenId: string,
+      query?: {
         /**
          * Page number
          * @format int32
-         * @min 1
          */
         page?: number
         /**
          * Number of items per page
          * @format int32
-         * @min 0
-         * @max 1000
          */
         limit?: number
       },
       params: RequestParams = {}
     ) =>
       this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/${address}/timeranged-transactions`,
+        path: `/addresses/${address}/tokens/${tokenId}/transactions`,
         method: 'GET',
         query: query,
         format: 'json',
@@ -1056,101 +1015,83 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse),
 
     /**
-     * @description List transactions of a given address
+     * @description Get address balance of given token
      *
      * @tags Addresses
-     * @name GetAddressesAddressTransactions
-     * @request GET:/addresses/{address}/transactions
+     * @name GetAddressesAddressTokensTokenIdBalance
+     * @request GET:/addresses/{address}/tokens/{token_id}/balance
      */
-    getAddressesAddressTransactions: (
-      address: string,
-      query?: {
-        /**
-         * Page number
-         * @format int32
-         * @min 1
-         */
-        page?: number
-        /**
-         * Number of items per page
-         * @format int32
-         * @min 0
-         * @max 100
-         */
-        limit?: number
-      },
-      params: RequestParams = {}
-    ) =>
-      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/${address}/transactions`,
+    getAddressesAddressTokensTokenIdBalance: (address: string, tokenId: string, params: RequestParams = {}) =>
+      this.request<
+        AddressTokenBalance,
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/addresses/${address}/tokens/${tokenId}/balance`,
         method: 'GET',
-        query: query,
         format: 'json',
         ...params
       }).then(convertHttpResponse),
 
     /**
-     * No description
+     * @description Get public key of p2pkh addresses, the address needs to have at least one input.
      *
      * @tags Addresses
-     * @name GetAddressesAddressAmountHistory
-     * @request GET:/addresses/{address}/amount-history
+     * @name GetAddressesAddressPublicKey
+     * @request GET:/addresses/{address}/public-key
      */
-    getAddressesAddressAmountHistory: (
-      address: string,
-      query: {
-        /**
-         * @format int64
-         * @min 0
-         */
-        fromTs: number
-        /**
-         * @format int64
-         * @min 0
-         */
-        toTs: number
-        'interval-type': IntervalType
-      },
-      params: RequestParams = {}
-    ) =>
-      this.request<AmountHistory, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/${address}/amount-history`,
+    getAddressesAddressPublicKey: (address: string, params: RequestParams = {}) =>
+      this.request<string, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/public-key`,
         method: 'GET',
-        query: query,
         format: 'json',
         ...params
       }).then(convertHttpResponse),
 
     /**
-     * @description List transactions for given addresses
+     * @description Get address tokens with balance
      *
      * @tags Addresses
-     * @name PostAddressesTransactions
-     * @request POST:/addresses/transactions
+     * @name GetAddressesAddressTokensBalance
+     * @request GET:/addresses/{address}/tokens-balance
      */
-    postAddressesTransactions: (
+    getAddressesAddressTokensBalance: (
+      address: string,
       query?: {
         /**
          * Page number
          * @format int32
-         * @min 1
          */
         page?: number
         /**
          * Number of items per page
          * @format int32
-         * @min 0
-         * @max 100
          */
         limit?: number
       },
-      data?: string[],
       params: RequestParams = {}
     ) =>
-      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/transactions`,
-        method: 'POST',
+      this.request<
+        AddressTokenBalance[],
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/addresses/${address}/tokens-balance`,
+        method: 'GET',
         query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Are the addresses used (at least 1 transaction)
+     *
+     * @tags Addresses, Addresses
+     * @name PostAddressesUsed
+     * @request POST:/addresses/used
+     */
+    postAddressesUsed: (data?: string[], params: RequestParams = {}) =>
+      this.request<boolean[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/used`,
+        method: 'POST',
         body: data,
         type: ContentType.Json,
         format: 'json',
@@ -1161,11 +1102,10 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * No description
      *
      * @tags Addresses
-     * @name GetAddressesAddressAmountHistoryDeprecated
-     * @request GET:/addresses/{address}/amount-history-DEPRECATED
-     * @deprecated
+     * @name GetAddressesAddressExportTransactionsCsv
+     * @request GET:/addresses/{address}/export-transactions/csv
      */
-    getAddressesAddressAmountHistoryDeprecated: (
+    getAddressesAddressExportTransactionsCsv: (
       address: string,
       query: {
         /**
@@ -1178,47 +1118,44 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
          * @min 0
          */
         toTs: number
-        'interval-type': IntervalType
       },
       params: RequestParams = {}
     ) =>
       this.request<string, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/${address}/amount-history-DEPRECATED`,
+        path: `/addresses/${address}/export-transactions/csv`,
         method: 'GET',
         query: query,
-        format: 'json',
+        format: 'text',
         ...params
       }).then(convertHttpResponse),
 
     /**
-     * @description List address tokens
+     * No description
      *
      * @tags Addresses
-     * @name GetAddressesAddressTokens
-     * @request GET:/addresses/{address}/tokens
+     * @name GetAddressesAddressAmountHistoryDeprecated
+     * @request GET:/addresses/{address}/amount-history-DEPRECATED
      * @deprecated
      */
-    getAddressesAddressTokens: (
+    getAddressesAddressAmountHistoryDeprecated: (
       address: string,
-      query?: {
+      query: {
         /**
-         * Page number
-         * @format int32
-         * @min 1
+         * @format int64
+         * @min 0
          */
-        page?: number
+        fromTs: number
         /**
-         * Number of items per page
-         * @format int32
+         * @format int64
          * @min 0
-         * @max 100
          */
-        limit?: number
+        toTs: number
+        'interval-type': IntervalType
       },
       params: RequestParams = {}
     ) =>
-      this.request<string[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/${address}/tokens`,
+      this.request<string, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/amount-history-DEPRECATED`,
         method: 'GET',
         query: query,
         format: 'json',
@@ -1226,91 +1163,68 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse),
 
     /**
-     * @description Get address tokens with balance
+     * No description
      *
      * @tags Addresses
-     * @name GetAddressesAddressTokensBalance
-     * @request GET:/addresses/{address}/tokens-balance
+     * @name GetAddressesAddressAmountHistory
+     * @request GET:/addresses/{address}/amount-history
      */
-    getAddressesAddressTokensBalance: (
+    getAddressesAddressAmountHistory: (
       address: string,
-      query?: {
+      query: {
         /**
-         * Page number
-         * @format int32
-         * @min 1
+         * @format int64
+         * @min 0
          */
-        page?: number
+        fromTs: number
         /**
-         * Number of items per page
-         * @format int32
+         * @format int64
          * @min 0
-         * @max 100
          */
-        limit?: number
+        toTs: number
+        'interval-type': IntervalType
       },
       params: RequestParams = {}
     ) =>
-      this.request<
-        AddressTokenBalance[],
-        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
-      >({
-        path: `/addresses/${address}/tokens-balance`,
+      this.request<AmountHistory, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/amount-history`,
         method: 'GET',
         query: query,
         format: 'json',
         ...params
-      }).then(convertHttpResponse),
-
+      }).then(convertHttpResponse)
+  }
+  infos = {
     /**
-     * @description Get address balance of given token
+     * @description Get explorer informations
      *
-     * @tags Addresses
-     * @name GetAddressesAddressTokensTokenIdBalance
-     * @request GET:/addresses/{address}/tokens/{token_id}/balance
+     * @tags Infos
+     * @name GetInfos
+     * @request GET:/infos
      */
-    getAddressesAddressTokensTokenIdBalance: (address: string, tokenId: string, params: RequestParams = {}) =>
-      this.request<
-        AddressTokenBalance,
-        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
-      >({
-        path: `/addresses/${address}/tokens/${tokenId}/balance`,
+    getInfos: (params: RequestParams = {}) =>
+      this.request<ExplorerInfo, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/infos`,
         method: 'GET',
         format: 'json',
         ...params
       }).then(convertHttpResponse),
 
     /**
-     * @description Get address information
+     * @description List latest height for each chain
      *
-     * @tags Addresses
-     * @name GetAddressesAddress
-     * @request GET:/addresses/{address}
+     * @tags Infos
+     * @name GetInfosHeights
+     * @request GET:/infos/heights
      */
-    getAddressesAddress: (address: string, params: RequestParams = {}) =>
-      this.request<AddressInfo, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/${address}`,
+    getInfosHeights: (params: RequestParams = {}) =>
+      this.request<PerChainHeight[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/infos/heights`,
         method: 'GET',
         format: 'json',
         ...params
       }).then(convertHttpResponse),
 
-    /**
-     * @description Get public key of p2pkh addresses, the address needs to have at least one input.
-     *
-     * @tags Addresses
-     * @name GetAddressesAddressPublicKey
-     * @request GET:/addresses/{address}/public-key
-     */
-    getAddressesAddressPublicKey: (address: string, params: RequestParams = {}) =>
-      this.request<string, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/addresses/${address}/public-key`,
-        method: 'GET',
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse)
-  }
-  infos = {
     /**
      * @description Get token supply list
      *
@@ -1323,14 +1237,11 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         /**
          * Page number
          * @format int32
-         * @min 1
          */
         page?: number
         /**
          * Number of items per page
          * @format int32
-         * @min 0
-         * @max 100
          */
         limit?: number
       },
@@ -1344,51 +1255,6 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
-    /**
-     * @description Get the ALPH locked supply
-     *
-     * @tags Infos
-     * @name GetInfosSupplyLockedAlph
-     * @request GET:/infos/supply/locked-alph
-     */
-    getInfosSupplyLockedAlph: (params: RequestParams = {}) =>
-      this.request<number, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/infos/supply/locked-alph`,
-        method: 'GET',
-        format: 'text',
-        ...params
-      }).then(convertHttpResponse),
-
-    /**
-     * @description Get explorer informations
-     *
-     * @tags Infos
-     * @name GetInfos
-     * @request GET:/infos
-     */
-    getInfos: (params: RequestParams = {}) =>
-      this.request<ExplorerInfo, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/infos`,
-        method: 'GET',
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse),
-
-    /**
-     * @description Get the ALPH circulating supply
-     *
-     * @tags Infos
-     * @name GetInfosSupplyCirculatingAlph
-     * @request GET:/infos/supply/circulating-alph
-     */
-    getInfosSupplyCirculatingAlph: (params: RequestParams = {}) =>
-      this.request<number, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/infos/supply/circulating-alph`,
-        method: 'GET',
-        format: 'text',
-        ...params
-      }).then(convertHttpResponse),
-
     /**
      * @description Get the ALPH total supply
      *
@@ -1405,15 +1271,15 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse),
 
     /**
-     * @description Get the total number of transactions
+     * @description Get the ALPH circulating supply
      *
      * @tags Infos
-     * @name GetInfosTotalTransactions
-     * @request GET:/infos/total-transactions
+     * @name GetInfosSupplyCirculatingAlph
+     * @request GET:/infos/supply/circulating-alph
      */
-    getInfosTotalTransactions: (params: RequestParams = {}) =>
+    getInfosSupplyCirculatingAlph: (params: RequestParams = {}) =>
       this.request<number, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/infos/total-transactions`,
+        path: `/infos/supply/circulating-alph`,
         method: 'GET',
         format: 'text',
         ...params
@@ -1435,121 +1301,87 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse),
 
     /**
-     * @description List latest height for each chain
+     * @description Get the ALPH locked supply
      *
      * @tags Infos
-     * @name GetInfosHeights
-     * @request GET:/infos/heights
+     * @name GetInfosSupplyLockedAlph
+     * @request GET:/infos/supply/locked-alph
      */
-    getInfosHeights: (params: RequestParams = {}) =>
-      this.request<PerChainHeight[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/infos/heights`,
+    getInfosSupplyLockedAlph: (params: RequestParams = {}) =>
+      this.request<number, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/infos/supply/locked-alph`,
         method: 'GET',
-        format: 'json',
+        format: 'text',
         ...params
       }).then(convertHttpResponse),
 
     /**
-     * @description Get the average block time for each chain
+     * @description Get the total number of transactions
      *
      * @tags Infos
-     * @name GetInfosAverageBlockTimes
-     * @request GET:/infos/average-block-times
-     */
-    getInfosAverageBlockTimes: (params: RequestParams = {}) =>
-      this.request<PerChainDuration[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>(
-        {
-          path: `/infos/average-block-times`,
-          method: 'GET',
-          format: 'json',
-          ...params
-        }
-      ).then(convertHttpResponse)
-  }
-  utils = {
-    /**
-     * @description Perform a sanity check
-     *
-     * @tags Utils
-     * @name PutUtilsSanityCheck
-     * @request PUT:/utils/sanity-check
-     */
-    putUtilsSanityCheck: (params: RequestParams = {}) =>
-      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/utils/sanity-check`,
-        method: 'PUT',
-        ...params
-      }).then(convertHttpResponse),
-
-    /**
-     * @description Update global log level, accepted: TRACE, DEBUG, INFO, WARN, ERROR
-     *
-     * @tags Utils
-     * @name PutUtilsUpdateGlobalLoglevel
-     * @request PUT:/utils/update-global-loglevel
-     */
-    putUtilsUpdateGlobalLoglevel: (data: 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR', params: RequestParams = {}) =>
-      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/utils/update-global-loglevel`,
-        method: 'PUT',
-        body: data,
+     * @name GetInfosTotalTransactions
+     * @request GET:/infos/total-transactions
+     */
+    getInfosTotalTransactions: (params: RequestParams = {}) =>
+      this.request<number, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/infos/total-transactions`,
+        method: 'GET',
+        format: 'text',
         ...params
       }).then(convertHttpResponse),
 
     /**
-     * @description Update logback values
+     * @description Get the average block time for each chain
      *
-     * @tags Utils
-     * @name PutUtilsUpdateLogConfig
-     * @request PUT:/utils/update-log-config
+     * @tags Infos
+     * @name GetInfosAverageBlockTimes
+     * @request GET:/infos/average-block-times
      */
-    putUtilsUpdateLogConfig: (data?: LogbackValue[], params: RequestParams = {}) =>
-      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/utils/update-log-config`,
-        method: 'PUT',
-        body: data,
-        type: ContentType.Json,
-        ...params
-      }).then(convertHttpResponse)
+    getInfosAverageBlockTimes: (params: RequestParams = {}) =>
+      this.request<PerChainDuration[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>(
+        {
+          path: `/infos/average-block-times`,
+          method: 'GET',
+          format: 'json',
+          ...params
+        }
+      ).then(convertHttpResponse)
   }
-  tokens = {
+  mempool = {
     /**
-     * @description Return metadata for the given fungible tokens, if metadata doesn't exist or token isn't a fungible, it won't be in the output list
+     * @description list mempool transactions
      *
-     * @tags Tokens
-     * @name PostTokensFungibleMetadata
-     * @request POST:/tokens/fungible-metadata
+     * @tags Mempool
+     * @name GetMempoolTransactions
+     * @request GET:/mempool/transactions
      */
-    postTokensFungibleMetadata: (data?: string[], params: RequestParams = {}) =>
+    getMempoolTransactions: (
+      query?: {
+        /**
+         * Page number
+         * @format int32
+         */
+        page?: number
+        /**
+         * Number of items per page
+         * @format int32
+         */
+        limit?: number
+      },
+      params: RequestParams = {}
+    ) =>
       this.request<
-        FungibleTokenMetadata[],
+        MempoolTransaction[],
         BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
       >({
-        path: `/tokens/fungible-metadata`,
-        method: 'POST',
-        body: data,
-        type: ContentType.Json,
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse),
-
-    /**
-     * @description List given tokens information
-     *
-     * @tags Tokens
-     * @name PostTokens
-     * @request POST:/tokens
-     */
-    postTokens: (data?: string[], params: RequestParams = {}) =>
-      this.request<TokenInfo[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/tokens`,
-        method: 'POST',
-        body: data,
-        type: ContentType.Json,
+        path: `/mempool/transactions`,
+        method: 'GET',
+        query: query,
         format: 'json',
         ...params
-      }).then(convertHttpResponse),
-
+      }).then(convertHttpResponse)
+  }
+  tokens = {
     /**
      * @description List token information
      *
@@ -1562,14 +1394,11 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         /**
          * Page number
          * @format int32
-         * @min 1
          */
         page?: number
         /**
          * Number of items per page
          * @format int32
-         * @min 0
-         * @max 100
          */
         limit?: number
         /**
@@ -1588,6 +1417,23 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * @description List given tokens information
+     *
+     * @tags Tokens
+     * @name PostTokens
+     * @request POST:/tokens
+     */
+    postTokens: (data?: string[], params: RequestParams = {}) =>
+      this.request<TokenInfo[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/tokens`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description List token transactions
      *
@@ -1601,14 +1447,11 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         /**
          * Page number
          * @format int32
-         * @min 1
          */
         page?: number
         /**
          * Number of items per page
          * @format int32
-         * @min 0
-         * @max 100
          */
         limit?: number
       },
@@ -1622,26 +1465,6 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
-    /**
-     * @description Return metadata for the given nft collection addresses, if metadata doesn't exist or address isn't a nft collection, it won't be in the output list
-     *
-     * @tags Tokens
-     * @name PostTokensNftCollectionMetadata
-     * @request POST:/tokens/nft-collection-metadata
-     */
-    postTokensNftCollectionMetadata: (data?: string[], params: RequestParams = {}) =>
-      this.request<
-        NFTCollectionMetadata[],
-        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
-      >({
-        path: `/tokens/nft-collection-metadata`,
-        method: 'POST',
-        body: data,
-        type: ContentType.Json,
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse),
-
     /**
      * @description List token addresses
      *
@@ -1655,14 +1478,11 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         /**
          * Page number
          * @format int32
-         * @min 1
          */
         page?: number
         /**
          * Number of items per page
          * @format int32
-         * @min 0
-         * @max 100
          */
         limit?: number
       },
@@ -1677,41 +1497,36 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse),
 
     /**
-     * @description Return metadata for the given nft tokens, if metadata doesn't exist or token isn't a nft, it won't be in the output list
+     * @description Return metadata for the given fungible tokens, if metadata doesn't exist or token isn't a fungible, it won't be in the output list
      *
      * @tags Tokens
-     * @name PostTokensNftMetadata
-     * @request POST:/tokens/nft-metadata
+     * @name PostTokensFungibleMetadata
+     * @request POST:/tokens/fungible-metadata
      */
-    postTokensNftMetadata: (data?: string[], params: RequestParams = {}) =>
-      this.request<NFTMetadata[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/tokens/nft-metadata`,
+    postTokensFungibleMetadata: (data?: string[], params: RequestParams = {}) =>
+      this.request<
+        FungibleTokenMetadata[],
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/tokens/fungible-metadata`,
         method: 'POST',
         body: data,
         type: ContentType.Json,
         format: 'json',
         ...params
-      }).then(convertHttpResponse)
-  }
-  market = {
+      }).then(convertHttpResponse),
+
     /**
-     * No description
+     * @description Return metadata for the given nft tokens, if metadata doesn't exist or token isn't a nft, it won't be in the output list
      *
-     * @tags Market
-     * @name PostMarketPrices
-     * @request POST:/market/prices
+     * @tags Tokens
+     * @name PostTokensNftMetadata
+     * @request POST:/tokens/nft-metadata
      */
-    postMarketPrices: (
-      query: {
-        currency: string
-      },
-      data?: string[],
-      params: RequestParams = {}
-    ) =>
-      this.request<number[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/market/prices`,
+    postTokensNftMetadata: (data?: string[], params: RequestParams = {}) =>
+      this.request<NFTMetadata[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/tokens/nft-metadata`,
         method: 'POST',
-        query: query,
         body: data,
         type: ContentType.Json,
         format: 'json',
@@ -1719,56 +1534,52 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse),
 
     /**
-     * No description
+     * @description Return metadata for the given nft collection addresses, if metadata doesn't exist or address isn't a nft collection, it won't be in the output list
      *
-     * @tags Market
-     * @name GetMarketPricesSymbolCharts
-     * @request GET:/market/prices/{symbol}/charts
+     * @tags Tokens
+     * @name PostTokensNftCollectionMetadata
+     * @request POST:/tokens/nft-collection-metadata
      */
-    getMarketPricesSymbolCharts: (
-      symbol: string,
-      query: {
-        currency: string
-      },
-      params: RequestParams = {}
-    ) =>
-      this.request<TimedPrices, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/market/prices/${symbol}/charts`,
-        method: 'GET',
-        query: query,
+    postTokensNftCollectionMetadata: (data?: string[], params: RequestParams = {}) =>
+      this.request<
+        NFTCollectionMetadata[],
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/tokens/nft-collection-metadata`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
         format: 'json',
         ...params
       }).then(convertHttpResponse)
   }
-  blocks = {
+  charts = {
     /**
-     * @description Get block's transactions
+     * @description `interval-type` query param: hourly, daily
      *
-     * @tags Blocks
-     * @name GetBlocksBlockHashTransactions
-     * @request GET:/blocks/{block_hash}/transactions
+     * @tags Charts
+     * @name GetChartsHashrates
+     * @summary Get hashrate chart in H/s
+     * @request GET:/charts/hashrates
      */
-    getBlocksBlockHashTransactions: (
-      blockHash: string,
-      query?: {
+    getChartsHashrates: (
+      query: {
         /**
-         * Page number
-         * @format int32
-         * @min 1
+         * @format int64
+         * @min 0
          */
-        page?: number
+        fromTs: number
         /**
-         * Number of items per page
-         * @format int32
+         * @format int64
          * @min 0
-         * @max 100
          */
-        limit?: number
+        toTs: number
+        'interval-type': IntervalType
       },
       params: RequestParams = {}
     ) =>
-      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/blocks/${blockHash}/transactions`,
+      this.request<Hashrate[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/charts/hashrates`,
         method: 'GET',
         query: query,
         format: 'json',
@@ -1776,71 +1587,72 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse),
 
     /**
-     * @description Get a block with hash
+     * @description `interval-type` query param: hourly, daily
      *
-     * @tags Blocks
-     * @name GetBlocksBlockHash
-     * @request GET:/blocks/{block_hash}
+     * @tags Charts
+     * @name GetChartsTransactionsCount
+     * @summary Get transaction count history
+     * @request GET:/charts/transactions-count
      */
-    getBlocksBlockHash: (blockHash: string, params: RequestParams = {}) =>
-      this.request<BlockEntry, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/blocks/${blockHash}`,
+    getChartsTransactionsCount: (
+      query: {
+        /**
+         * @format int64
+         * @min 0
+         */
+        fromTs: number
+        /**
+         * @format int64
+         * @min 0
+         */
+        toTs: number
+        'interval-type': IntervalType
+      },
+      params: RequestParams = {}
+    ) =>
+      this.request<TimedCount[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/charts/transactions-count`,
         method: 'GET',
+        query: query,
         format: 'json',
         ...params
       }).then(convertHttpResponse),
 
     /**
-     * @description List latest blocks
+     * @description `interval-type` query param: hourly, daily
      *
-     * @tags Blocks
-     * @name GetBlocks
-     * @request GET:/blocks
+     * @tags Charts
+     * @name GetChartsTransactionsCountPerChain
+     * @summary Get transaction count history per chain
+     * @request GET:/charts/transactions-count-per-chain
      */
-    getBlocks: (
-      query?: {
+    getChartsTransactionsCountPerChain: (
+      query: {
         /**
-         * Page number
-         * @format int32
-         * @min 1
+         * @format int64
+         * @min 0
          */
-        page?: number
+        fromTs: number
         /**
-         * Number of items per page
-         * @format int32
+         * @format int64
          * @min 0
-         * @max 100
          */
-        limit?: number
-        /** Reverse pagination */
-        reverse?: boolean
+        toTs: number
+        'interval-type': IntervalType
       },
       params: RequestParams = {}
     ) =>
-      this.request<ListBlocks, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/blocks`,
+      this.request<
+        PerChainTimedCount[],
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/charts/transactions-count-per-chain`,
         method: 'GET',
         query: query,
         format: 'json',
         ...params
       }).then(convertHttpResponse)
   }
-  transactions = {
-    /**
-     * @description Get a transaction with hash
-     *
-     * @tags Transactions
-     * @name GetTransactionsTransactionHash
-     * @request GET:/transactions/{transaction_hash}
-     */
-    getTransactionsTransactionHash: (transactionHash: string, params: RequestParams = {}) =>
-      this.request<TransactionLike, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/transactions/${transactionHash}`,
-        method: 'GET',
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse)
-  }
   contractEvents = {
     /**
      * @description Get contract events by transaction id
@@ -1870,14 +1682,11 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         /**
          * Page number
          * @format int32
-         * @min 1
          */
         page?: number
         /**
          * Number of items per page
          * @format int32
-         * @min 0
-         * @max 100
          */
         limit?: number
       },
@@ -1905,14 +1714,11 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         /**
          * Page number
          * @format int32
-         * @min 1
          */
         page?: number
         /**
          * Number of items per page
          * @format int32
-         * @min 0
-         * @max 100
          */
         limit?: number
       },
@@ -1926,140 +1732,158 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse)
   }
-  charts = {
+  contracts = {
     /**
-     * @description `interval-type` query param: hourly, daily
+     * @description Get contract liveness
      *
-     * @tags Charts
-     * @name GetChartsTransactionsCountPerChain
-     * @summary Get transaction count history per chain
-     * @request GET:/charts/transactions-count-per-chain
+     * @tags Contracts
+     * @name GetContractsContractAddressCurrentLiveness
+     * @request GET:/contracts/{contract_address}/current-liveness
      */
-    getChartsTransactionsCountPerChain: (
-      query: {
+    getContractsContractAddressCurrentLiveness: (contractAddress: string, params: RequestParams = {}) =>
+      this.request<ContractLiveness, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/contracts/${contractAddress}/current-liveness`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Get contract parent address if exist
+     *
+     * @tags Contracts
+     * @name GetContractsContractAddressParent
+     * @request GET:/contracts/{contract_address}/parent
+     */
+    getContractsContractAddressParent: (contractAddress: string, params: RequestParams = {}) =>
+      this.request<ContractParent, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/contracts/${contractAddress}/parent`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Get sub contract addresses
+     *
+     * @tags Contracts
+     * @name GetContractsContractAddressSubContracts
+     * @request GET:/contracts/{contract_address}/sub-contracts
+     */
+    getContractsContractAddressSubContracts: (
+      contractAddress: string,
+      query?: {
         /**
-         * @format int64
-         * @min 0
+         * Page number
+         * @format int32
          */
-        fromTs: number
+        page?: number
         /**
-         * @format int64
-         * @min 0
+         * Number of items per page
+         * @format int32
          */
-        toTs: number
-        'interval-type': IntervalType
+        limit?: number
       },
       params: RequestParams = {}
     ) =>
-      this.request<
-        PerChainTimedCount[],
-        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
-      >({
-        path: `/charts/transactions-count-per-chain`,
+      this.request<SubContracts, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/contracts/${contractAddress}/sub-contracts`,
         method: 'GET',
         query: query,
         format: 'json',
         ...params
-      }).then(convertHttpResponse),
-
+      }).then(convertHttpResponse)
+  }
+  market = {
     /**
-     * @description `interval-type` query param: hourly, daily
+     * No description
      *
-     * @tags Charts
-     * @name GetChartsTransactionsCount
-     * @summary Get transaction count history
-     * @request GET:/charts/transactions-count
+     * @tags Market
+     * @name PostMarketPrices
+     * @request POST:/market/prices
      */
-    getChartsTransactionsCount: (
+    postMarketPrices: (
       query: {
-        /**
-         * @format int64
-         * @min 0
-         */
-        fromTs: number
-        /**
-         * @format int64
-         * @min 0
-         */
-        toTs: number
-        'interval-type': IntervalType
+        currency: string
       },
+      data?: string[],
       params: RequestParams = {}
     ) =>
-      this.request<TimedCount[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/charts/transactions-count`,
-        method: 'GET',
+      this.request<number[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/market/prices`,
+        method: 'POST',
         query: query,
+        body: data,
+        type: ContentType.Json,
         format: 'json',
         ...params
       }).then(convertHttpResponse),
 
     /**
-     * @description `interval-type` query param: hourly, daily
+     * No description
      *
-     * @tags Charts
-     * @name GetChartsHashrates
-     * @summary Get hashrate chart in H/s
-     * @request GET:/charts/hashrates
+     * @tags Market
+     * @name GetMarketPricesSymbolCharts
+     * @request GET:/market/prices/{symbol}/charts
      */
-    getChartsHashrates: (
+    getMarketPricesSymbolCharts: (
+      symbol: string,
       query: {
-        /**
-         * @format int64
-         * @min 0
-         */
-        fromTs: number
-        /**
-         * @format int64
-         * @min 0
-         */
-        toTs: number
-        'interval-type': IntervalType
+        currency: string
       },
       params: RequestParams = {}
     ) =>
-      this.request<Hashrate[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/charts/hashrates`,
+      this.request<TimedPrices, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/market/prices/${symbol}/charts`,
         method: 'GET',
         query: query,
         format: 'json',
         ...params
       }).then(convertHttpResponse)
   }
-  mempool = {
+  utils = {
     /**
-     * @description list mempool transactions
+     * @description Perform a sanity check
      *
-     * @tags Mempool
-     * @name GetMempoolTransactions
-     * @request GET:/mempool/transactions
+     * @tags Utils
+     * @name PutUtilsSanityCheck
+     * @request PUT:/utils/sanity-check
      */
-    getMempoolTransactions: (
-      query?: {
-        /**
-         * Page number
-         * @format int32
-         * @min 1
-         */
-        page?: number
-        /**
-         * Number of items per page
-         * @format int32
-         * @min 0
-         * @max 100
-         */
-        limit?: number
-      },
-      params: RequestParams = {}
-    ) =>
-      this.request<
-        MempoolTransaction[],
-        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
-      >({
-        path: `/mempool/transactions`,
-        method: 'GET',
-        query: query,
-        format: 'json',
+    putUtilsSanityCheck: (params: RequestParams = {}) =>
+      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/utils/sanity-check`,
+        method: 'PUT',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Update global log level, accepted: TRACE, DEBUG, INFO, WARN, ERROR
+     *
+     * @tags Utils
+     * @name PutUtilsUpdateGlobalLoglevel
+     * @request PUT:/utils/update-global-loglevel
+     */
+    putUtilsUpdateGlobalLoglevel: (data: 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR', params: RequestParams = {}) =>
+      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/utils/update-global-loglevel`,
+        method: 'PUT',
+        body: data,
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Update logback values
+     *
+     * @tags Utils
+     * @name PutUtilsUpdateLogConfig
+     * @request PUT:/utils/update-log-config
+     */
+    putUtilsUpdateLogConfig: (data?: LogbackValue[], params: RequestParams = {}) =>
+      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/utils/update-log-config`,
+        method: 'PUT',
+        body: data,
+        type: ContentType.Json,
         ...params
       }).then(convertHttpResponse)
   }