How to use the @reactivex/ix-es2015-cjs/asynciterable/asynciterablex.AsyncIterableX.from function in @reactivex/ix-es2015-cjs

public iterStorage(address: AddressString): AsyncIterable {
    return AsyncIterableX.from(this.mutableClient.getAllStorage(address).then((res) => AsyncIterableX.from(res))).pipe(
      // tslint:disable-next-line no-any
      flatten() as any,
      map((storageItem) => this.convertStorageItem(storageItem)),
    );
  }

public concat(
    other: StackItemEnumerator,
  ): StackItemEnumerator {
    const iterable = concat(
      AsyncIterableX.from(this.enumerator as AsyncIterableIterator),
      AsyncIterableX.from(other.enumerator as AsyncIterableIterator),
    );

    return new StackItemEnumerator(iterable[Symbol.asyncIterator]());
  }
}

public concat(
    other: StackItemEnumerator,
  ): StackItemEnumerator {
    const iterable = concat(
      AsyncIterableX.from(this.enumerator as AsyncIterableIterator),
      AsyncIterableX.from(other.enumerator as AsyncIterableIterator),
    );

    return new StackItemEnumerator(iterable[Symbol.asyncIterator]());
  }
}

const iterActionsRaw = ({
    network = client.getCurrentNetwork(),
    ...iterOptions
  }: SmartContractIterOptions = {}): AsyncIterable =>
    AsyncIterableX.from(client.__iterActionsRaw(network, iterOptions)).pipe(
      filter((action) => action.address === definition.networks[network].address),
    );

const iterEvents = (actionFilter?: BlockFilter): AsyncIterable =>
    AsyncIterableX.from(iterActions(actionFilter)).pipe(
      map((action) => {
        if (action.type === 'Log') {
          return undefined;
        }

        return action;
      }),
      filter(Boolean),
    );

const iterActions = (options?: SmartContractIterOptions): AsyncIterable =>
    AsyncIterableX.from(iterActionsRaw(options)).pipe(
      map(convertAction),
      filter(utils.notNull),
    );

invoke: async ({ context, args }) => {
      const hash = vmUtils.toStorageContext({ context, value: args[0] }).value;
      await checkStorage({ context, hash });

      const prefix = args[1].asBuffer();
      const iterable = AsyncIterableX.from(context.blockchain.storageItem.getAll$({ hash, prefix })).pipe<{
        key: BufferStackItem;
        value: BufferStackItem;
      }>(
        asyncMap(({ key, value }) => ({
          key: new BufferStackItem(key),
          value: new BufferStackItem(value),
        })),
      );

      return {
        context,
        results: [new IteratorStackItem(new StackItemIterator(iterable[Symbol.asyncIterator]()))],
      };
    },
  }),

public iterActionsRaw(options: IterOptions = {}): AsyncIterable {
    return AsyncIterableX.from(this.getProvider()).pipe(
      flatMap((provider) => provider.iterActionsRaw(options)),
    );
  }

private async startInternal(options: InternalOptions): Promise {
    logger.info({ name: 'neo_consensus_start' }, 'Consensus started.');

    const initialResult = await initializeNewConsensus({
      blockchain: this.node.blockchain,
      publicKey: options.publicKey,
      consensusContext: this.mutableConsensusContext,
    });

    await AsyncIterableX.from(this.mutableQueue)
      .pipe(
        scan(async (context: Context, event: Event) => {
          let result;
          switch (event.type) {
            case 'handlePersistBlock':
              result = await handlePersistBlock({
                blockchain: this.node.blockchain,
                publicKey: options.publicKey,
                consensusContext: this.mutableConsensusContext,
              });

              break;
            case 'handleConsensusPayload':
              result = await handleConsensusPayload({
                context,
                node: this.node,