Class Metadata

constructor

• new Metadata(magicNumber, metadata): Metadata

• Parameters

  • magicNumber: number
  • metadata:
        | {
            type: "V1";
            value: never;
        }
        | {
            type: "V0";
            value: never;
        }
        | {
            type: "V2";
            value: never;
        }
        | {
            type: "V3";
            value: never;
        }
        | {
            type: "V4";
            value: never;
        }
        | {
            type: "V5";
            value: never;
        }
        | {
            type: "V6";
            value: never;
        }
        | {
            type: "V7";
            value: never;
        }
        | {
            type: "V8";
            value: never;
        }
        | {
            type: "V9";
            value: never;
        }
        | {
            type: "V10";
            value: never;
        }
        | {
            type: "V11";
            value: never;
        }
        | {
            type: "V12";
            value: never;
        }
        | {
            type: "V13";
            value: never;
        }
        | {
            type: "V14";
            value: {
                extrinsic: {
                    signedExtensions: {
                        additionalSigned: number;
                        ident: string;
                        typeId: number;
                    }[];
                    typeId: number;
                    version: number;
                };
                pallets: {
                    calls: undefined | number;
                    constants: {
                        docs: string[];
                        name: string;
                        typeId: number;
                        value: `0x${string}`;
                    }[];
                    error: undefined | number;
                    event: undefined | number;
                    index: number;
                    name: string;
                    storage: undefined | {
                        entries: {
                            default: `0x${string}`;
                            docs: string[];
                            modifier: string;
                            name: string;
                            storageType: {
                                type: ...;
                                value: ...;
                            } | {
                                type: ...;
                                value: ...;
                            };
                        }[];
                        prefix: string;
                    };
                }[];
                runtimeType: number;
                types: {
                    docs: string[];
                    id: number;
                    params: {
                        name: string;
                        typeId: undefined | number;
                    }[];
                    path: string[];
                    typeDef:
                        | {
                            type: "Struct";
                            value: {
                                fields: Field[];
                            };
                        }
                        | {
                            type: "Enum";
                            value: {
                                members: {
                                    docs: (...)[];
                                    fields: (...)[];
                                    index: number;
                                    name: string;
                                }[];
                            };
                        }
                        | {
                            type: "Sequence";
                            value: {
                                typeParam: number;
                            };
                        }
                        | {
                            type: "SizedVec";
                            value: {
                                len: number;
                                typeParam: number;
                            };
                        }
                        | {
                            type: "Tuple";
                            value: {
                                fields: number[];
                            };
                        }
                        | {
                            type: "Primitive";
                            value: {
                                kind:
                                    | "bool"
                                    | "char"
                                    | "str"
                                    | "u8"
                                    | "u16"
                                    | "u32"
                                    | "u64"
                                    | "u128"
                                    | "u256"
                                    | "i8"
                                    | "i16"
                                    | "i32"
                                    | "i64"
                                    | "i128"
                                    | "i256";
                            };
                        }
                        | {
                            type: "Compact";
                            value: {
                                typeParam: number;
                            };
                        }
                        | {
                            type: "BitSequence";
                            value: {
                                bitOrderType: number;
                                bitStoreType: number;
                            };
                        };
                }[];
            };
        }
        | {
            type: "V15";
            value: {
                apis: {
                    docs: string[];
                    methods: {
                        docs: string[];
                        inputs: {
                            name: string;
                            typeId: number;
                        }[];
                        name: string;
                        output: number;
                    }[];
                    name: string;
                }[];
                custom: {
                    map: ReadonlyMap<string, {
                        typeId: number;
                        value: `0x${string}`;
                    }>;
                };
                extrinsic: {
                    addressTypeId: number;
                    callTypeId: number;
                    extraTypeId: number;
                    signatureTypeId: number;
                    signedExtensions: {
                        additionalSigned: number;
                        ident: string;
                        typeId: number;
                    }[];
                    version: number;
                };
                outerEnums: {
                    callEnumTypeId: number;
                    errorEnumTypeId: number;
                    eventEnumTypeId: number;
                };
                pallets: {
                    calls: undefined | number;
                    constants: {
                        docs: string[];
                        name: string;
                        typeId: number;
                        value: `0x${string}`;
                    }[];
                    docs: string[];
                    error: undefined | number;
                    event: undefined | number;
                    index: number;
                    name: string;
                    storage: undefined | {
                        entries: {
                            default: `0x${string}`;
                            docs: string[];
                            modifier: string;
                            name: string;
                            storageType: {
                                type: ...;
                                value: ...;
                            } | {
                                type: ...;
                                value: ...;
                            };
                        }[];
                        prefix: string;
                    };
                }[];
                runtimeType: number;
                types: {
                    docs: string[];
                    id: number;
                    params: {
                        name: string;
                        typeId: undefined | number;
                    }[];
                    path: string[];
                    typeDef:
                        | {
                            type: "Struct";
                            value: {
                                fields: Field[];
                            };
                        }
                        | {
                            type: "Enum";
                            value: {
                                members: {
                                    docs: (...)[];
                                    fields: (...)[];
                                    index: number;
                                    name: string;
                                }[];
                            };
                        }
                        | {
                            type: "Sequence";
                            value: {
                                typeParam: number;
                            };
                        }
                        | {
                            type: "SizedVec";
                            value: {
                                len: number;
                                typeParam: number;
                            };
                        }
                        | {
                            type: "Tuple";
                            value: {
                                fields: number[];
                            };
                        }
                        | {
                            type: "Primitive";
                            value: {
                                kind:
                                    | "bool"
                                    | "char"
                                    | "str"
                                    | "u8"
                                    | "u16"
                                    | "u32"
                                    | "u64"
                                    | "u128"
                                    | "u256"
                                    | "i8"
                                    | "i16"
                                    | "i32"
                                    | "i64"
                                    | "i128"
                                    | "i256";
                            };
                        }
                        | {
                            type: "Compact";
                            value: {
                                typeParam: number;
                            };
                        }
                        | {
                            type: "BitSequence";
                            value: {
                                bitOrderType: number;
                                bitStoreType: number;
                            };
                        };
                }[];
            };
        }

  Returns Metadata

magicNumber

metadataVersioned

latest

• get latest(): {
      apis: {
          docs: string[];
          methods: {
              docs: string[];
              inputs: {
                  name: string;
                  typeId: number;
              }[];
              name: string;
              output: number;
          }[];
          name: string;
      }[];
      custom: {
          map: ReadonlyMap<string, {
              typeId: number;
              value: `0x${string}`;
          }>;
      };
      extrinsic: {
          addressTypeId: number;
          callTypeId: number;
          extraTypeId: number;
          signatureTypeId: number;
          signedExtensions: {
              additionalSigned: number;
              ident: string;
              typeId: number;
          }[];
          version: number;
      };
      outerEnums: {
          callEnumTypeId: number;
          errorEnumTypeId: number;
          eventEnumTypeId: number;
      };
      pallets: {
          calls: undefined | number;
          constants: {
              docs: string[];
              name: string;
              typeId: number;
              value: `0x${string}`;
          }[];
          docs: string[];
          error: undefined | number;
          event: undefined | number;
          index: number;
          name: string;
          storage: undefined | {
              entries: {
                  default: `0x${string}`;
                  docs: string[];
                  modifier: string;
                  name: string;
                  storageType: {
                      type: "Plain";
                      value: {
                          valueTypeId: number;
                      };
                  } | {
                      type: "Map";
                      value: {
                          hashers: (...)[];
                          keyTypeId: number;
                          valueTypeId: number;
                      };
                  };
              }[];
              prefix: string;
          };
      }[];
      runtimeType: number;
      types: {
          docs: string[];
          id: number;
          params: {
              name: string;
              typeId: undefined | number;
          }[];
          path: string[];
          typeDef:
              | {
                  type: "Struct";
                  value: {
                      fields: Field[];
                  };
              }
              | {
                  type: "Enum";
                  value: {
                      members: {
                          docs: string[];
                          fields: Field[];
                          index: number;
                          name: string;
                      }[];
                  };
              }
              | {
                  type: "Sequence";
                  value: {
                      typeParam: number;
                  };
              }
              | {
                  type: "SizedVec";
                  value: {
                      len: number;
                      typeParam: number;
                  };
              }
              | {
                  type: "Tuple";
                  value: {
                      fields: number[];
                  };
              }
              | {
                  type: "Primitive";
                  value: {
                      kind:
                          | "bool"
                          | "char"
                          | "str"
                          | "u8"
                          | "u16"
                          | "u32"
                          | "u64"
                          | "u128"
                          | "u256"
                          | "i8"
                          | "i16"
                          | "i32"
                          | "i64"
                          | "i128"
                          | "i256";
                  };
              }
              | {
                  type: "Compact";
                  value: {
                      typeParam: number;
                  };
              }
              | {
                  type: "BitSequence";
                  value: {
                      bitOrderType: number;
                      bitStoreType: number;
                  };
              };
      }[];
  }

• Returns {
      apis: {
          docs: string[];
          methods: {
              docs: string[];
              inputs: {
                  name: string;
                  typeId: number;
              }[];
              name: string;
              output: number;
          }[];
          name: string;
      }[];
      custom: {
          map: ReadonlyMap<string, {
              typeId: number;
              value: `0x${string}`;
          }>;
      };
      extrinsic: {
          addressTypeId: number;
          callTypeId: number;
          extraTypeId: number;
          signatureTypeId: number;
          signedExtensions: {
              additionalSigned: number;
              ident: string;
              typeId: number;
          }[];
          version: number;
      };
      outerEnums: {
          callEnumTypeId: number;
          errorEnumTypeId: number;
          eventEnumTypeId: number;
      };
      pallets: {
          calls: undefined | number;
          constants: {
              docs: string[];
              name: string;
              typeId: number;
              value: `0x${string}`;
          }[];
          docs: string[];
          error: undefined | number;
          event: undefined | number;
          index: number;
          name: string;
          storage: undefined | {
              entries: {
                  default: `0x${string}`;
                  docs: string[];
                  modifier: string;
                  name: string;
                  storageType: {
                      type: "Plain";
                      value: {
                          valueTypeId: number;
                      };
                  } | {
                      type: "Map";
                      value: {
                          hashers: (...)[];
                          keyTypeId: number;
                          valueTypeId: number;
                      };
                  };
              }[];
              prefix: string;
          };
      }[];
      runtimeType: number;
      types: {
          docs: string[];
          id: number;
          params: {
              name: string;
              typeId: undefined | number;
          }[];
          path: string[];
          typeDef:
              | {
                  type: "Struct";
                  value: {
                      fields: Field[];
                  };
              }
              | {
                  type: "Enum";
                  value: {
                      members: {
                          docs: string[];
                          fields: Field[];
                          index: number;
                          name: string;
                      }[];
                  };
              }
              | {
                  type: "Sequence";
                  value: {
                      typeParam: number;
                  };
              }
              | {
                  type: "SizedVec";
                  value: {
                      len: number;
                      typeParam: number;
                  };
              }
              | {
                  type: "Tuple";
                  value: {
                      fields: number[];
                  };
              }
              | {
                  type: "Primitive";
                  value: {
                      kind:
                          | "bool"
                          | "char"
                          | "str"
                          | "u8"
                          | "u16"
                          | "u32"
                          | "u64"
                          | "u128"
                          | "u256"
                          | "i8"
                          | "i16"
                          | "i32"
                          | "i64"
                          | "i128"
                          | "i256";
                  };
              }
              | {
                  type: "Compact";
                  value: {
                      typeParam: number;
                  };
              }
              | {
                  type: "BitSequence";
                  value: {
                      bitOrderType: number;
                      bitStoreType: number;
                  };
              };
      }[];
  }

  • apis: {
        docs: string[];
        methods: {
            docs: string[];
            inputs: {
                name: string;
                typeId: number;
            }[];
            name: string;
            output: number;
        }[];
        name: string;
    }[]

  • custom: {
        map: ReadonlyMap<string, {
            typeId: number;
            value: `0x${string}`;
        }>;
    }

    • map: ReadonlyMap<string, {
          typeId: number;
          value: `0x${string}`;
      }>

  • extrinsic: {
        addressTypeId: number;
        callTypeId: number;
        extraTypeId: number;
        signatureTypeId: number;
        signedExtensions: {
            additionalSigned: number;
            ident: string;
            typeId: number;
        }[];
        version: number;
    }

    • addressTypeId: number

    • callTypeId: number

    • extraTypeId: number

    • signatureTypeId: number

    • signedExtensions: {
          additionalSigned: number;
          ident: string;
          typeId: number;
      }[]

    • version: number

  • outerEnums: {
        callEnumTypeId: number;
        errorEnumTypeId: number;
        eventEnumTypeId: number;
    }

    • callEnumTypeId: number

    • errorEnumTypeId: number

    • eventEnumTypeId: number

  • pallets: {
        calls: undefined | number;
        constants: {
            docs: string[];
            name: string;
            typeId: number;
            value: `0x${string}`;
        }[];
        docs: string[];
        error: undefined | number;
        event: undefined | number;
        index: number;
        name: string;
        storage: undefined | {
            entries: {
                default: `0x${string}`;
                docs: string[];
                modifier: string;
                name: string;
                storageType: {
                    type: "Plain";
                    value: {
                        valueTypeId: number;
                    };
                } | {
                    type: "Map";
                    value: {
                        hashers: (...)[];
                        keyTypeId: number;
                        valueTypeId: number;
                    };
                };
            }[];
            prefix: string;
        };
    }[]

  • runtimeType: number

  • types: {
        docs: string[];
        id: number;
        params: {
            name: string;
            typeId: undefined | number;
        }[];
        path: string[];
        typeDef:
            | {
                type: "Struct";
                value: {
                    fields: Field[];
                };
            }
            | {
                type: "Enum";
                value: {
                    members: {
                        docs: string[];
                        fields: Field[];
                        index: number;
                        name: string;
                    }[];
                };
            }
            | {
                type: "Sequence";
                value: {
                    typeParam: number;
                };
            }
            | {
                type: "SizedVec";
                value: {
                    len: number;
                    typeParam: number;
                };
            }
            | {
                type: "Tuple";
                value: {
                    fields: number[];
                };
            }
            | {
                type: "Primitive";
                value: {
                    kind:
                        | "bool"
                        | "char"
                        | "str"
                        | "u8"
                        | "u16"
                        | "u32"
                        | "u64"
                        | "u128"
                        | "u256"
                        | "i8"
                        | "i16"
                        | "i32"
                        | "i64"
                        | "i128"
                        | "i256";
                };
            }
            | {
                type: "Compact";
                value: {
                    typeParam: number;
                };
            }
            | {
                type: "BitSequence";
                value: {
                    bitOrderType: number;
                    bitStoreType: number;
                };
            };
    }[]

version

• get version():
      | "V1"
      | "V0"
      | "V2"
      | "V3"
      | "V4"
      | "V5"
      | "V6"
      | "V7"
      | "V8"
      | "V9"
      | "V10"
      | "V11"
      | "V12"
      | "V13"
      | "V14"
      | "V15"

• Returns
      | "V1"
      | "V0"
      | "V2"
      | "V3"
      | "V4"
      | "V5"
      | "V6"
      | "V7"
      | "V8"
      | "V9"
      | "V10"
      | "V11"
      | "V12"
      | "V13"
      | "V14"
      | "V15"

versionNumber

• get versionNumber(): number

• Returns number