util#promisify TypeScript Examples

export async function countInstructions (txHash: string, instructions: string[]) {
    if (!web3.currentProvider || typeof web3.currentProvider === 'string' || !web3.currentProvider.send) {
        throw new Error('Unsupported provider');
    }
    const trace = await promisify(web3.currentProvider.send.bind(web3.currentProvider))({
        jsonrpc: '2.0',
        method: 'debug_traceTransaction',
        params: [txHash, {}],
        id: new Date().getTime(),
    });

    const str = JSON.stringify(trace);

    return instructions.map(instr => {
        return str.split('"' + instr.toUpperCase() + '"').length - 1;
    });
}

hive.broadcast.comment = promisify(hive.broadcast.comment)

async takePNGScreenshot(): Promise<PNG> {
    const resolution = await this.vboxDisplay!.getScreenResolution(0);
    const screenshot = await this.vboxDisplay!.takeScreenShotToArray(
      0,
      resolution.width,
      resolution.height,
      BitmapFormat.PNG
    );
    const imageBuffer = Buffer.from(screenshot, "base64");
    const image = new PNG();
    const parseImage = promisify(image.parse.bind(image));
    await parseImage(imageBuffer);
    return image;
  }

sleep = promisify(setTimeout)

export function wrapProvider(provider: TruffleProvider): EthereumProvider {
  const sendAsync = ('sendAsync' in provider ? provider.sendAsync : provider.send).bind(provider);
  const send = promisify(sendAsync);
  return {
    async send(method: string, params: unknown[]) {
      const id = crypto.randomBytes(4).toString('hex');
      const { result, error } = await send({ jsonrpc: '2.0', method, params, id });
      if (error) {
        throw new Error(error.message);
      } else {
        return result;
      }
    },
  };
}

private async loadAsync(): Promise<StorageDatabase> {
        try {
            const readFile = promisify(fs.readFile);
            this.lastFlushedSerializedDatabase = (await readFile(this.dbPath)).toString();

            return JSON.parse(this.lastFlushedSerializedDatabase);
        } catch (error) {
            if (error.code !== 'ENOENT') {
                this.onError(error);
            }

            return {};
        }
    }

constructor(app: App, private plugin: TemplaterPlugin) {
        if (
            Platform.isMobileApp ||
            !(app.vault.adapter instanceof FileSystemAdapter)
        ) {
            this.cwd = "";
        } else {
            this.cwd = app.vault.adapter.getBasePath();
            this.exec_promise = promisify(exec);
        }
    }

export async function detectInstallation(): Promise<IWTInstallation | undefined> {
  const config = vscode.workspace.getConfiguration('windowsTerminal');
  const channelConfig = config.get<Channel | 'auto'>('channel') || 'auto';

  let channel: Channel;
  if (channelConfig === 'auto') {
    const pathExists = await promisify(exists)(getExecutablePath('stable'));
    channel = 'stable';
    if (!pathExists) {
      // Switch to preview only if it exists, we want the stable store page to open if not
      const previewExists = await promisify(exists)(getExecutablePath('preview'));
      if (previewExists) {
        channel = 'preview';
      }
    }
  } else {
    channel = channelConfig;
  }

  const installation: IWTInstallation = {
    executablePath: getExecutablePath(channel),
    settingsPath: getSettingsPath(channel)
  };

  const exeExists = await promisify(exists)(installation.executablePath);
  if (!exeExists) {
    const selection = await vscode.window.showErrorMessage('Could not detect Windows Terminal installation', 'Open Microsoft Store');
    if (selection === 'Open Microsoft Store') {
      const url = channel === 'stable'
        ? 'https://www.microsoft.com/en-us/p/windows-terminal/9n0dx20hk701'
        : 'https://www.microsoft.com/en-us/p/windows-terminal-preview/9n8g5rfz9xk3';
      await vscode.env.openExternal(vscode.Uri.parse(url));
    }
    return undefined;
  }

  return installation;
}

async function receiveUpdateMessage(event: any) {
  const time_end = performance.now();
  if (time_start !== null) {
    console.log(`Roundtrip: ${time_end - time_start}ms`);
    time_start = null;
  }

  const data = Buffer.from(Buffer.from(event.data, 'base64'), 4);
  const do_unzip = promisify(inflate);
  const unzipped_data = await do_unzip(data);

  const message = JSON.parse(unzipped_data as unknown as string);
  if (message.key === 'mission_updated') {
    Object.keys(missionUpdateListeners).forEach(key => missionUpdateListeners[key](message.value));
  } else if (message.key === 'sessionid') {
    Object.keys(sessionIdUpdateListeners).forEach(key => sessionIdUpdateListeners[key](message.value));
  } else if (message.key === 'sessions_updated') {
    Object.keys(sessionsUpdateListeners).forEach(key => sessionsUpdateListeners[key](message.value));
  } else {
    Object.keys(genericUpdateListeners).forEach(key => genericUpdateListeners[key](message));
  }
}

/**
   * This method checks the token and returns the decoded data when token is valid in all respect
   */
  public static async validate(token: string): Promise<JwtPayload> {
    const cert = await this.readPublicKey();
    try {
      // @ts-ignore
      return (await promisify(verify)(token, cert)) as JwtPayload;
    } catch (e) {
      Logger.debug(e);
      if (e && e.name === 'TokenExpiredError') throw new TokenExpiredError();
      // throws error if the token has not been encrypted by the private key
      throw new BadTokenError();
    }
  }

/**
 * Downloads repo from git url to destination path
 * @param url git url (<organization/repo>)
 * @param destination location to download repo
 */
export async function fetchRepository (url: string, destination: string): Promise<void> {
  try {
    // eslint-disable-next-line @typescript-eslint/no-misused-promises
    await promisify(download)(url, destination);
  } catch (error) {
    console.error(`Failed to initialize ${url}`);
    throw error;
  }
}

createCertificate: (
  options: pem.CertificateCreationOptions
) => Promise<pem.CertificateCreationResult> = promisify(pem.createCertificate)

pReadFile = promisify(readFile)

cors = (
  options?: CorsOptions | CorsOptionsDelegate<IncomingMessage>,
): Middleware<any, MaybeAsyncResponse> => {
  const cors = promisify(
    Cors(
      typeof options === 'function'
        ? options
        : {
            ...options,
            preflightContinue: true,
          },
    ),
  )

  return async (request, next) => {
    const req = useReq()
    const res = useRes()

    try {
      await cors(req, res)
      if (req.method?.toLowerCase() === 'options') {
        if (typeof options === 'object') {
          if (options.preflightContinue) {
            return next(request)
          }
        }
        return Response.status(204).string('')
      }
      return next(request)
    } catch (error: any) {
      return Response.status(500).text(error.message)
    }
  }
}

exec = promisify(ChildProcess.exec)

async function writeLog(
  lang: string,
  type: string,
  result: string,
  log: string
) {
  log = `${result.toUpperCase()}: ${lang}/${type}\n` + log;
  await promisify(fs.mkdir)(`tests/${lang}`, { recursive: true });
  await promisify(fs.writeFile)(`tests/${lang}/${type}.log`, log);
  await promisify(fs.mkdir)(`tests-run/${lang}`, { recursive: true });
  await promisify(fs.symlink)(
    `../../tests/${lang}/${type}.log`,
    `tests-run/${lang}/${type}.log`
  );
  await promisify(fs.mkdir)(`tests-${result}/${lang}`, { recursive: true });
  await promisify(fs.symlink)(
    `../../tests/${lang}/${type}.log`,
    `tests-${result}/${lang}/${type}.log`
  );
}

exists = promisify(fs.exists)

async function dumpFile(client: PoolClient, outfile: string): Promise<void> {
  const promisifiedPipeline = promisify(pipeline);

  const copyStream = client.query(
    copyTo(
      format(
        `
      COPY %I TO STDOUT WITH (
      FORMAT csv,
      HEADER true,
      DELIMITER ','
    )`,
        config.productTableName
      )
    )
  );

  const gzip = zlib.createGzip().on('error', (e) => {
    config.logger.info(e);
    process.exit(1);
  });

  const fileStream = fs.createWriteStream(`${outfile}`);

  return promisifiedPipeline(copyStream, gzip, fileStream);
}

exists = promisify(origFs.exists)

async checkSigAgainstStellar(pathAndSigs: PathAndSigsJSON, expectedHash: Sha256Hash): Promise<TreeRoots> {
    // First check that the hash of the signature was reflected in the
    // stellar blockchain, as expected.
    const reporter = this.reporter.step(`check hash equality for ${chalk.italic(expectedHash)}`)
    reporter.start()
    const sig = pathAndSigs.root.sigs[keybaseRootKid].sig
    const sigDecoded = Buffer.from(sig, 'base64')
    const gotHash = sha256(sigDecoded)
    if (expectedHash != gotHash) {
      throw new Error('hash mismatch for grove sig and stellar memo')
    }

    // Verify the signature is valid, and signed with the expected key
    const f = promisify(kb.verify)
    const sigPayload = await f({binary: sigDecoded, kid: keybaseRootKid})

    // The next 5 lines aren't necessary, since they are already performed inside
    // of kb.verify, but we repeat them here to be explicit that the `sig` object
    // also contains the text of what the signature was over.
    const object = decode(sigDecoded) as KeybaseSig
    const treeRootsEncoded = Buffer.from(object.body.payload)
    if (sigPayload.compare(treeRootsEncoded) != 0) {
      throw new Error('buffer comparison failed and should have been the same')
    }

    // Parse and return the root sig payload
    reporter.success('match')
    return JSON.parse(treeRootsEncoded.toString('ascii')) as TreeRoots
  }

export async function gasspectEVM (txHash: string, gasspectOptions: Record<string, unknown> = {}, optionalTraceFile?: PathLike | fs.FileHandle) {
    const options = { ...gasspectOptionsDefault, ...gasspectOptions };

    if (!web3.currentProvider || typeof web3.currentProvider === 'string' || !web3.currentProvider.send) {
        throw new Error('Unsupported provider');
    }

    const trace = await promisify(web3.currentProvider.send.bind(web3.currentProvider))({
        jsonrpc: '2.0',
        method: 'debug_traceTransaction',
        params: [txHash, {}],
        id: new Date().getTime(),
    });

    const ops: Op[] = trace?.result.structLogs;

    const traceAddress = [0, -1];
    for (const [i, op] of ops.entries()) {
        op.traceAddress = traceAddress.slice(0, traceAddress.length - 1);
        _normalizeOp(ops, i);

        if (op.depth + 2 > traceAddress.length) {
            traceAddress[traceAddress.length - 1] += 1;
            traceAddress.push(-1);
        }

        if (op.depth + 2 < traceAddress.length) {
            traceAddress.pop();
        }
    }

    const result = ops.filter(op => op.gasCost > options.minOpGasCost).map(op => op.traceAddress.join('-') + '-' + op.op +
                        (options.args ? '(' + (op.args || []).join(',') + ')' : '') +
                        (options.res ? (op.res ? ':0x' + op.res : '') : '') +
                        ' = ' + op.gasCost);

    if (optionalTraceFile) {
        await fs.writeFile(optionalTraceFile, JSON.stringify(result));
    }

    return result;
}

hive.broadcast.comment = promisify(hive.broadcast.comment)

execFileP = promisify(execFile)

(async () => {
  try {
    const argv = await yargs
      .default("http-host", "0.0.0.0")
      .default("http-port", 7779)
      .default("tcp-host", "127.0.0.1")
      .default("tcp-port", 4449).argv;

    const startListening = function (serverName: string, serverObject: any) {
      serverObject.listen(
        argv[`${serverName}-port`],
        argv[`${serverName}-host`]
      );
      serverObject.on("listening", function () {
        console.log(
          `${serverName} server listening on ${formatAddress(
            serverObject.address()
          )}`
        );
      });
    };

    const { httpServer, screenReaderTcpServer } =
      await createPlaywrightServer();
    let closing = false;
    process.on("SIGINT", async () => {
      if (!closing) {
        closing = true;
        await promisify(httpServer.close.bind(httpServer))();
      }
      process.exit(0);
    });
    sigintWin32();
    startListening("tcp", screenReaderTcpServer);
    startListening("http", httpServer);
  } catch (error) {
    console.error(error);
    process.exit(1);
  }
})();

status.on('update', async (data) => {
  if (!db.connected) await promisify(setTimeout)(2000)

  const body = generateEmbed(data)

  postUpdate(body, db)
    .catch(console.error)
})

private async _fetch<T>(options: NewIAPIParams): Promise<T> {
		await this._queue.delay();
		const whileExectued = RestAPIHandler.globalTimeout;
		await promisify(setTimeout)(whileExectued);
		RestAPIHandler.globalTimeout -= whileExectued;
		try {
			await promisify(setTimeout)(this._cooldown);
			this._cooldown = 1;
			const res = await fetch(`${CONSTANTS.Api}${options.endpoint}`, {
				method: options.method,
				headers: {
					"Content-Type": "application/json",
					Authorization: `Bot ${this._client.token}`,
				},
				body: options.json_params,
			});

			const json = await res.json();

			if (res.headers) {
				const resetAfter =
					Number(
						res.headers.get("x-ratelimit-reset-after") ?? json.retry_after
					) * 1000;
				if (this._cooldown !== 0) {
					this._cooldown += resetAfter;
				} else this._cooldown = resetAfter;
			}

			if (res.status === 429) {
				if (json.global) RestAPIHandler.globalTimeout += this._cooldown;
				await promisify(setTimeout)(this._cooldown);
				return this._fetch<T>(options);
			}

			if (!res.ok) {
				const rejection = new DiscordRejection({
					code: json.code,
					msg: this._client.transformer.error(json.message),
					http: res.status,
					path: options.endpoint,
				});

				if (this._client.listenerCount(EVENTS.API_ERROR) < 1) {
					throw rejection;
				} else throw this._client.emit(EVENTS.API_ERROR, rejection);
			}
			return json;
		} catch (e) {
			if (this._client.listenerCount(EVENTS.API_ERROR) < 1)
				throw this._client.transformer.error(e);
			else throw this._client.emit(EVENTS.API_ERROR, e);
		} finally {
			this._cooldown = 1;
			this._queue.dequeue();
		}
	}

read = promisify(fs.read)

streamPipeline = promisify(require('stream').pipeline)

appendFileAsync = promisify(appendFile)