Class Executor<ChainApi>Abstract

constructor

• new Executor<ChainApi>(client, atBlockHash?): Executor<ChainApi>

• Type Parameters

  • ChainApi extends GenericSubstrateApi<RpcVersion> = GenericSubstrateApi<RpcVersion>

  Parameters

  • client: ISubstrateClientAt<ChainApi>
  • OptionalatBlockHash: `0x${string}`

  Returns Executor<ChainApi>

Readonlyclient

atBlockHash

• get atBlockHash(): undefined | `0x${string}`

• Returns undefined | `0x${string}`

metadata

• get metadata(): {
      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;
                };
            };
    }[]

registry

• get registry(): PortableRegistry

• Returns PortableRegistry

AbstractdoExecute

• doExecute(...paths): unknown

• Parameters

  • Rest...paths: string[]

  Returns unknown

execute

• execute(...paths): unknown

• Parameters

  • Rest...paths: string[]

  Returns unknown

getPallet

• getPallet(name): {
      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: (
                          | "identity"
                          | "blake2_128"
                          | "blake2_256"
                          | "blake2_128Concat"
                          | "twox128"
                          | "twox256"
                          | "twox64Concat")[];
                      keyTypeId: number;
                      valueTypeId: number;
                  };
              };
          }[];
          prefix: string;
      };
  }

• Parameters

  • name: string

  Returns {
      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: (
                          | "identity"
                          | "blake2_128"
                          | "blake2_256"
                          | "blake2_128Concat"
                          | "twox128"
                          | "twox256"
                          | "twox64Concat")[];
                      keyTypeId: number;
                      valueTypeId: number;
                  };
              };
          }[];
          prefix: string;
      };
  }

  • 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: (
                        | "identity"
                        | "blake2_128"
                        | "blake2_256"
                        | "blake2_128Concat"
                        | "twox128"
                        | "twox256"
                        | "twox64Concat")[];
                    keyTypeId: number;
                    valueTypeId: number;
                };
            };
        }[];
        prefix: string;
    }