@silvana-one/mina-utils 0.2.0

package/src/transactions/send.ts

@@ -0,0 +1,228 @@
+import { checkZkappTransaction } from "o1js";
+import { Mina } from "o1js";
+import { blockchain } from "../networks.js";
+import { sleep } from "../utils/utils.js";
+import { fetchMinaAccount } from "../utils/fetch.js";
+import { getCurrentNetwork } from "../utils/mina.js";
+
+/**
+ * The function `sendTx` sends a transaction, checks account updates, and waits for
+ * confirmation on the blockchain.
+ * @param params The parameters object
+ * @param params.tx The transaction to send
+ * @param params.description A description of the transaction
+ * @param params.verbose Whether to log verbose information
+ * @param params.wait Whether to wait for the transaction to be included in a block
+ * @param params.chain The blockchain to send the transaction on
+ * @returns The `sendTx` function returns a `Mina.IncludedTransaction`, `Mina.PendingTransaction`,
+ * `Mina.RejectedTransaction`, or `undefined` if there was an error during the process.
+ */
+export async function sendTx(params: {
+  tx: Mina.Transaction<false, true> | Mina.Transaction<true, true>;
+  description?: string;
+  retry?: number;
+  verbose?: boolean;
+  wait?: boolean;
+  chain?: blockchain;
+  delay?: number;
+}): Promise<
+  | Mina.IncludedTransaction
+  | Mina.PendingTransaction
+  | Mina.RejectedTransaction
+  | undefined
+> {
+  const {
+    tx,
+    description = "",
+    verbose = true,
+    wait = true,
+    chain = getCurrentNetwork().network.chainId,
+    delay = chain === "zeko" || chain === "lightnet" ? 5000 : 60000,
+    retry = 30,
+  } = params;
+  // flatten accountUpdates
+  const accountUpdates = JSON.parse(tx.toJSON()).accountUpdates;
+  const auCount: {
+    publicKey: string;
+    tokenId: string | undefined;
+    count: number;
+  }[] = [];
+  let proofAuthorizationCount = 0;
+  // Calculate the number of account updates for each { publicKey, tokenId }
+  for (const au of accountUpdates) {
+    const { publicKey, tokenId, authorizationKind } = au.body;
+    if (au.authorization.proof) {
+      proofAuthorizationCount++;
+      if (authorizationKind.isProved === false)
+        console.error("Proof authorization exists but isProved is false");
+    } else if (authorizationKind.isProved === true)
+      console.error("isProved is true but no proof authorization");
+    const index = auCount.findIndex(
+      (item) => item.publicKey === publicKey && item.tokenId === tokenId
+    );
+    if (index === -1) auCount.push({ publicKey, tokenId, count: 1 });
+    else auCount[index].count++;
+  }
+  if (verbose)
+    console.log(
+      `Account updates for ${description ?? "tx"}: ${
+        auCount.length
+      }, proof authorizations: ${proofAuthorizationCount}`
+    );
+  for (const au of auCount) {
+    if (au.count > 1)
+      if (verbose)
+        console.log(
+          `DUPLICATE AU ${description ?? ""}: ${au.publicKey}  ${
+            au.tokenId !== "wSHV2S4qX9jFsLjQo8r1BsMLH2ZRKsZx6EJd1sbozGPieEC4Jf"
+              ? "tokenId: " + au.tokenId
+              : ""
+          } count: ${au.count}`
+        );
+  }
+  try {
+    let txSent;
+    let sent = false;
+    let attempt = 1;
+    while (!sent && attempt <= retry) {
+      txSent = await tx.safeSend();
+      if (txSent.status === "pending") {
+        sent = true;
+        if (verbose)
+          console.log(
+            `${description ?? ""} tx sent: hash: ${txSent.hash} status: ${
+              txSent.status
+            }`
+          );
+      } else if (chain !== "local") {
+        attempt++;
+        console.error(
+          `${description} tx NOT sent: hash: ${txSent?.hash} status: ${
+            txSent?.status
+          }, errors: ${String(txSent.errors ?? "")}`
+        );
+        if (verbose) console.log(`Retrying ${chain} tx, retry:`, attempt);
+        await sleep(10000 * attempt);
+      } else attempt = retry + 1; // local chain - do not retry
+    }
+    if (txSent === undefined) throw new Error("txSent is undefined");
+    if ((txSent.errors?.length ?? 0) > 0) {
+      console.error(
+        `${description ?? ""} tx error: hash: ${txSent.hash} status: ${
+          txSent.status
+        }  errors: ${String(txSent.errors ?? "")}`
+      );
+    }
+
+    if (txSent.status === "pending" && wait !== false && chain !== "zeko") {
+      if (verbose) console.log(`Waiting for tx inclusion...`);
+      let txIncluded = await txSent.safeWait();
+      if (txIncluded.status !== "included") {
+        console.error(
+          `${description ?? ""} tx NOT included into block: hash: ${
+            txIncluded.hash
+          } status: ${txIncluded.status}, errors: ${String(
+            txIncluded.errors ?? ""
+          )}`
+        );
+      }
+      if (chain !== "local") {
+        // we still wait for the tx to be included in the block by checking the nonce
+        // even in the case of tx NOT included
+        // because the tx might still be included in the block in the case of devnet instability
+        const { publicKey, nonce } = tx.transaction.feePayer.body;
+        const started = Date.now();
+        while (Date.now() - started < 1000 * 60 * 10) {
+          const newNonce = (
+            await fetchMinaAccount({
+              publicKey,
+              force: true,
+            })
+          ).account?.nonce;
+          if (
+            newNonce &&
+            Number(newNonce.toBigint()) > Number(nonce.toBigint())
+          ) {
+            let txIncluded = await txSent.safeWait();
+            if (txIncluded.status === "included") {
+              if (verbose)
+                console.log(
+                  `${description ?? ""} tx included into block: hash: ${
+                    txIncluded.hash
+                  } status: ${txIncluded.status}`
+                );
+              if (delay > 0) await sleep(delay);
+              return txIncluded;
+            } else if (txIncluded.status === "rejected") {
+              // We never should see this error as the nonce is updated (except when tx failed due to a preconditions),
+              // so we retry to check if the tx is included
+              console.error(
+                `tx rejected: ${chain}: hash: ${txIncluded.hash} status: ${txIncluded.status} errors: ${txIncluded.errors}`
+              );
+              await sleep(30000);
+              txIncluded = await txSent.safeWait();
+              if (txIncluded.status === "included") {
+                if (verbose)
+                  console.log(
+                    `${description ?? ""} tx included into block: hash: ${
+                      txIncluded.hash
+                    } status: ${txIncluded.status}`
+                  );
+                if (delay > 0) await sleep(delay);
+                return txIncluded;
+              }
+              console.error(
+                `tx failed: ${chain}: hash: ${txIncluded.hash} status: ${txIncluded.status} errors: ${txIncluded.errors}`
+              );
+              return txIncluded;
+            }
+          }
+          if (verbose)
+            console.log(
+              `Waiting for ${chain} to update state for ${Math.floor(
+                (Date.now() - started) / 1000
+              )} sec...`
+            );
+          await sleep(30000);
+        }
+        // finally, if the tx is still not included, show an error
+        console.error(
+          `${chain} do not reflect nonce update for tx ${txIncluded.hash} with status ${txIncluded.status}`
+        );
+      }
+      if (verbose)
+        console.log(
+          `${description ?? ""} tx included into block: hash: ${
+            txIncluded.hash
+          } status: ${txIncluded.status}`
+        );
+      return txIncluded;
+    } else return txSent;
+  } catch (error) {
+    if (chain !== "zeko") console.error("Error sending tx", error);
+  }
+}
+
+export async function getTxStatusFast(params: {
+  hash: string;
+  chain?: blockchain;
+}): Promise<{ success: boolean; result?: boolean; error?: string }> {
+  const { hash, chain = getCurrentNetwork().network.chainId } = params;
+  if (chain === "local" || chain === "zeko")
+    return { success: true, result: true };
+
+  try {
+    const txStatus = await checkZkappTransaction(hash);
+    return {
+      success: true,
+      result: txStatus?.success ?? false,
+    };
+  } catch (error: any) {
+    console.error(
+      "getTxStatusFast error while getting tx status - catch",
+      hash,
+      error
+    );
+    return { success: false, error: error?.message ?? "Cannot get tx status" };
+  }
+}

package/src/transactions/tiny-contract.ts

@@ -0,0 +1,9 @@
+import { Field, SmartContract, method, state, State } from "o1js";
+
+export class TinyContract extends SmartContract {
+  @state(Field) value = State<Field>();
+
+  @method async setValue(value: Field) {
+    this.value.set(value);
+  }
+}

package/src/transactions/transaction.ts

@@ -0,0 +1,319 @@
+import { Field, PublicKey, Transaction, Mina, UInt64 } from "o1js";
+import { TransactionPayloads } from "@silvana-one/api";
+import { fieldToBase64, fieldFromBase64 } from "../utils/base64-field.js";
+
+export function createTransactionPayloads(
+  tx: Mina.Transaction<false, false> | Mina.Transaction<false, true>
+): TransactionPayloads {
+  const transaction = tx.toJSON();
+  const txJSON = JSON.parse(transaction);
+  const signedData = JSON.stringify({ zkappCommand: txJSON });
+  const proverPayload = serializeTransaction(tx);
+  const fee = tx.transaction.feePayer.body.fee.toJSON();
+  const sender = tx.transaction.feePayer.body.publicKey.toBase58();
+  const nonce = Number(tx.transaction.feePayer.body.nonce.toBigint());
+  const memo = tx.transaction.memo;
+  const minaSignerPayload = {
+    zkappCommand: txJSON,
+    feePayer: {
+      feePayer: sender,
+      fee,
+      nonce,
+      memo,
+    },
+  };
+  const walletPayload = {
+    transaction,
+    nonce,
+    onlySign: true,
+    feePayer: {
+      fee,
+      memo,
+    },
+  };
+
+  return {
+    sender,
+    nonce,
+    memo,
+    fee,
+    walletPayload,
+    minaSignerPayload,
+    proverPayload,
+    signedData,
+    transaction,
+  };
+}
+
+interface ForestSerialized {
+  length: number;
+  restoredItems?: number;
+  items: {
+    h?: string; // hash
+    p?: string; // previousHash
+    i?: number; // id
+    c?: string; // callData
+  }[];
+}
+
+export function transactionParams(
+  params:
+    | {
+        proverPayload: string;
+        signedData: string;
+      }
+    | TransactionPayloads
+): {
+  fee: UInt64;
+  sender: PublicKey;
+  nonce: number;
+  memo: string;
+} {
+  const { proverPayload, signedData } = params;
+  const signedJson = JSON.parse(signedData);
+  const { sender, tx } = JSON.parse(proverPayload);
+  const transaction = Mina.Transaction.fromJSON(JSON.parse(tx));
+  const memo = transaction.transaction.memo;
+  return {
+    fee: UInt64.from(signedJson.zkappCommand.feePayer.body.fee),
+    sender: PublicKey.fromBase58(sender),
+    nonce: Number(signedJson.zkappCommand.feePayer.body.nonce),
+    memo,
+  };
+}
+
+export function parseTransactionPayloads(
+  params:
+    | {
+        proverPayload: string;
+        signedData: string;
+        txNew: Mina.Transaction<false, false> | Mina.Transaction<false, true>;
+      }
+    | {
+        payloads: TransactionPayloads;
+        txNew: Mina.Transaction<false, false> | Mina.Transaction<false, true>;
+      }
+): Transaction<false, true> {
+  const { txNew } = params;
+  const proverPayload =
+    "payloads" in params ? params.payloads.proverPayload : params.proverPayload;
+  const signedData =
+    "payloads" in params ? params.payloads.signedData : params.signedData;
+  const signedJson = JSON.parse(signedData);
+  const { tx, blindingValues, length, forestJSONs } = JSON.parse(proverPayload);
+  const transaction = Mina.Transaction.fromJSON(JSON.parse(tx));
+  const forests: ForestSerialized[] = forestJSONs.map(
+    (f: string) => JSON.parse(f) as ForestSerialized
+  );
+
+  if (length !== txNew.transaction.accountUpdates.length) {
+    throw new Error(
+      `New Transaction length mismatch: ${length} !== ${txNew.transaction.accountUpdates.length}`
+    );
+  }
+  if (length !== transaction.transaction.accountUpdates.length) {
+    throw new Error(
+      `Serialized Transaction length mismatch: ${length} !== ${transaction.transaction.accountUpdates.length}`
+    );
+  }
+  for (let i = 0; i < length; i++) {
+    transaction.transaction.accountUpdates[i].lazyAuthorization =
+      txNew.transaction.accountUpdates[i].lazyAuthorization;
+    if (blindingValues[i] !== "") {
+      if (
+        transaction.transaction.accountUpdates[i].lazyAuthorization ===
+          undefined ||
+        (transaction.transaction.accountUpdates[i].lazyAuthorization as any)
+          .blindingValue === undefined
+      ) {
+        throw new Error(
+          `Lazy authorization blinding value is undefined for item ${i}`
+        );
+      }
+      (
+        transaction.transaction.accountUpdates[i].lazyAuthorization as any
+      ).blindingValue = Field.fromJSON(blindingValues[i]);
+    }
+    if (forests[i].length > 0) {
+      if (
+        transaction.transaction.accountUpdates[i].lazyAuthorization ===
+          undefined ||
+        (transaction.transaction.accountUpdates[i].lazyAuthorization as any)
+          .args === undefined
+      ) {
+        throw new Error(`Lazy authorization args is undefined for item ${i}`);
+      }
+      deserializeLazyAuthorization(
+        (transaction.transaction.accountUpdates[i].lazyAuthorization as any)
+          .args,
+        forests[i]
+      );
+      if (forests[i].restoredItems !== forests[i].length) {
+        throw new Error(`Forest ${i} not fully restored`);
+      }
+    }
+  }
+  transaction.transaction.feePayer.authorization =
+    signedJson.zkappCommand.feePayer.authorization;
+  transaction.transaction.feePayer.body.fee = UInt64.from(
+    signedJson.zkappCommand.feePayer.body.fee
+  );
+  for (let i = 0; i < length; i++) {
+    const signature =
+      signedJson.zkappCommand.accountUpdates[i].authorization.signature;
+    if (signature !== undefined && signature !== null) {
+      transaction.transaction.accountUpdates[i].authorization.signature =
+        signedJson.zkappCommand.accountUpdates[i].authorization.signature;
+    }
+  }
+  return transaction;
+}
+
+export function serializeTransaction(
+  tx: Mina.Transaction<false, false> | Mina.Transaction<false, true>
+): string {
+  const length = tx.transaction.accountUpdates.length;
+  let i;
+  const blindingValues = [];
+  const forests: ForestSerialized[] = [];
+  for (i = 0; i < length; i++) {
+    const la = tx.transaction.accountUpdates[i].lazyAuthorization;
+    if (
+      la !== undefined &&
+      (la as any).blindingValue !== undefined &&
+      la.kind === "lazy-proof"
+    )
+      blindingValues.push(la.blindingValue.toJSON());
+    else blindingValues.push("");
+    const forest: ForestSerialized = { length: 0, items: [] };
+    serializeLazyAuthorization(
+      (tx.transaction.accountUpdates[i].lazyAuthorization as any)?.args,
+      forest
+    );
+    forests.push(forest);
+  }
+  const serializedTransaction = JSON.stringify(
+    {
+      tx: tx.toJSON(),
+      blindingValues,
+      forestJSONs: forests.map((f) => JSON.stringify(f)),
+      length,
+      fee: tx.transaction.feePayer.body.fee.toJSON(),
+      sender: tx.transaction.feePayer.body.publicKey.toBase58(),
+      nonce: tx.transaction.feePayer.body.nonce.toBigint().toString(),
+    },
+    null,
+    2
+  );
+  return serializedTransaction;
+}
+
+function serializeLazyAuthorization(
+  lazyAuthorization: any,
+  serialized: ForestSerialized
+): void {
+  if (lazyAuthorization?.hash !== undefined && lazyAuthorization.hash.toJSON) {
+    serialized.items.push({
+      h: fieldToBase64(lazyAuthorization.hash),
+    });
+  }
+
+  if (
+    lazyAuthorization?.previousHash !== undefined &&
+    lazyAuthorization.previousHash.toJSON
+  ) {
+    serialized.items.push({
+      p: fieldToBase64(lazyAuthorization.previousHash),
+    });
+  }
+  if (
+    lazyAuthorization?.callData !== undefined &&
+    lazyAuthorization.callData.toJSON
+  ) {
+    serialized.items.push({
+      c: fieldToBase64(lazyAuthorization.callData),
+    });
+  }
+
+  if (lazyAuthorization?.id !== undefined) {
+    serialized.items.push({
+      i: lazyAuthorization.id,
+    });
+  }
+
+  if (Array.isArray(lazyAuthorization)) {
+    for (const item of lazyAuthorization) {
+      serializeLazyAuthorization(item, serialized);
+    }
+  }
+  if (typeof lazyAuthorization === "object") {
+    for (const key in lazyAuthorization) {
+      serializeLazyAuthorization(lazyAuthorization[key], serialized);
+    }
+  }
+  serialized.length = serialized.items.length;
+}
+
+function deserializeLazyAuthorization(
+  lazyAuthorization: any,
+  serialized: ForestSerialized
+): void {
+  if (serialized.restoredItems === undefined) serialized.restoredItems = 0;
+  if (lazyAuthorization?.hash !== undefined && lazyAuthorization.hash.toJSON) {
+    if (serialized.restoredItems >= serialized.length)
+      throw new Error("Restored more items than expected");
+    const hash = serialized.items[serialized.restoredItems].h;
+    if (hash === undefined)
+      throw new Error(`Hash is undefined for item ${serialized.restoredItems}`);
+    lazyAuthorization.hash = fieldFromBase64(hash);
+
+    serialized.restoredItems++;
+  }
+  if (
+    lazyAuthorization?.previousHash !== undefined &&
+    lazyAuthorization.previousHash.toJSON
+  ) {
+    if (serialized.restoredItems >= serialized.length)
+      throw new Error("Restored more items than expected");
+    const previousHash = serialized.items[serialized.restoredItems].p;
+    if (previousHash === undefined)
+      throw new Error(
+        `Previous hash is undefined for item ${serialized.restoredItems}`
+      );
+    lazyAuthorization.previousHash = fieldFromBase64(previousHash);
+    serialized.restoredItems++;
+  }
+  if (
+    lazyAuthorization?.callData !== undefined &&
+    lazyAuthorization.callData.toJSON
+  ) {
+    if (serialized.restoredItems >= serialized.length)
+      throw new Error("Restored more items than expected");
+    const callData = serialized.items[serialized.restoredItems].c;
+    if (callData === undefined)
+      throw new Error(
+        `Call data is undefined for item ${serialized.restoredItems}`
+      );
+    lazyAuthorization.callData = fieldFromBase64(callData);
+    serialized.restoredItems++;
+  }
+  if (lazyAuthorization?.id !== undefined) {
+    if (serialized.restoredItems >= serialized.length)
+      throw new Error("Restored more items than expected");
+    const id = serialized.items[serialized.restoredItems].i;
+    if (id === undefined)
+      throw new Error(`Id is undefined for item ${serialized.restoredItems}`);
+    lazyAuthorization.id = id;
+    serialized.restoredItems++;
+  }
+  if (Array.isArray(lazyAuthorization)) {
+    for (const item of lazyAuthorization) {
+      deserializeLazyAuthorization(item, serialized);
+    }
+  }
+  if (typeof lazyAuthorization === "object") {
+    for (const key in lazyAuthorization) {
+      deserializeLazyAuthorization(lazyAuthorization[key], serialized);
+    }
+  }
+}

package/src/transactions/txstatus.ts

@@ -0,0 +1,26 @@
+import { BlockBerryChain } from "./chain.js";
+import { getZkAppTxFromBlockBerry } from "./blockberry.js";
+const TIMEOUT = 1000 * 60 * 21;
+
+export async function txStatusBlockberry(params: {
+  hash: string;
+  time: number;
+  chain: BlockBerryChain;
+  blockBerryApiKey: string;
+  timeout?: number;
+}): Promise<string> {
+  const { hash, chain, time, blockBerryApiKey } = params;
+
+  const tx = await getZkAppTxFromBlockBerry({ hash, chain, blockBerryApiKey });
+  if (tx?.txStatus) return tx?.txStatus;
+  if (Date.now() - time > (params.timeout ?? TIMEOUT)) {
+    console.error(
+      "txStatus: Timeout while checking tx with blockberry",
+      chain,
+      hash
+    );
+    return "replaced";
+  } else {
+    return "pending";
+  }
+}

package/src/utils/base64-field.ts

@@ -0,0 +1,34 @@
+import { Field } from "o1js";
+import { toBase, fromBase } from "./base64.js";
+
+// URL friendly base64 encoding
+const TABLE =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+export function fieldToBase56(field: Field): string {
+  const digits = toBase(field.toBigInt(), 56n);
+  //console.log("digits:", digits);
+  const str = digits.map((x) => TABLE[Number(x)]).join("");
+  //console.log("str:", str);
+  return str;
+}
+
+export function fieldFromBase56(str: string): Field {
+  const base56Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
+  const x = fromBase(base56Digits, 56n);
+  return Field(x);
+}
+
+export function fieldToBase64(field: Field): string {
+  const digits = toBase(field.toBigInt(), 64n);
+  //console.log("digits:", digits);
+  const str = digits.map((x) => TABLE[Number(x)]).join("");
+  //console.log("str:", str);
+  return str;
+}
+
+export function fieldFromBase64(str: string): Field {
+  const base64Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
+  const x = fromBase(base64Digits, 64n);
+  return Field(x);
+}

package/src/utils/base64.ts

@@ -0,0 +1,87 @@
+// URL friendly base64 encoding
+const TABLE =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+export function bigintToBase56(value: bigint): string {
+  const digits = toBase(value, 56n);
+  //console.log("digits:", digits);
+  const str = digits.map((x) => TABLE[Number(x)]).join("");
+  //console.log("str:", str);
+  return str;
+}
+
+export function bigintFromBase56(str: string): bigint {
+  const base56Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
+  const x = fromBase(base56Digits, 56n);
+  return x;
+}
+
+export function bigintToBase64(value: bigint): string {
+  const digits = toBase(value, 64n);
+  //console.log("digits:", digits);
+  const str = digits.map((x) => TABLE[Number(x)]).join("");
+  //console.log("str:", str);
+  return str;
+}
+
+export function bigintFromBase64(str: string): bigint {
+  const base64Digits = str.split("").map((x) => BigInt(TABLE.indexOf(x)));
+  const x = fromBase(base64Digits, 64n);
+  return x;
+}
+
+export function fromBase(digits: bigint[], base: bigint) {
+  if (base <= 0n) throw Error("fromBase: base must be positive");
+  // compute powers base, base^2, base^4, ..., base^(2^k)
+  // with largest k s.t. n = 2^k < digits.length
+  let basePowers = [];
+  for (let power = base, n = 1; n < digits.length; power **= 2n, n *= 2) {
+    basePowers.push(power);
+  }
+  let k = basePowers.length;
+  // pad digits array with zeros s.t. digits.length === 2^k
+  digits = digits.concat(Array(2 ** k - digits.length).fill(0n));
+  // accumulate [x0, x1, x2, x3, ...] -> [x0 + base*x1, x2 + base*x3, ...] -> [x0 + base*x1 + base^2*(x2 + base*x3), ...] -> ...
+  // until we end up with a single element
+  for (let i = 0; i < k; i++) {
+    let newDigits = Array(digits.length >> 1);
+    let basePower = basePowers[i];
+    for (let j = 0; j < newDigits.length; j++) {
+      newDigits[j] = digits[2 * j] + basePower * digits[2 * j + 1];
+    }
+    digits = newDigits;
+  }
+  console.assert(digits.length === 1);
+  let [digit] = digits;
+  return digit;
+}
+
+export function toBase(x: bigint, base: bigint) {
+  if (base <= 0n) throw Error("toBase: base must be positive");
+  // compute powers base, base^2, base^4, ..., base^(2^k)
+  // with largest k s.t. base^(2^k) < x
+  let basePowers = [];
+  for (let power = base; power <= x; power **= 2n) {
+    basePowers.push(power);
+  }
+  let digits = [x]; // single digit w.r.t base^(2^(k+1))
+  // successively split digits w.r.t. base^(2^j) into digits w.r.t. base^(2^(j-1))
+  // until we arrive at digits w.r.t. base
+  let k = basePowers.length;
+  for (let i = 0; i < k; i++) {
+    let newDigits = Array(2 * digits.length);
+    let basePower = basePowers[k - 1 - i];
+    for (let j = 0; j < digits.length; j++) {
+      let x = digits[j];
+      let high = x / basePower;
+      newDigits[2 * j + 1] = high;
+      newDigits[2 * j] = x - high * basePower;
+    }
+    digits = newDigits;
+  }
+  // pop "leading" zero digits
+  while (digits[digits.length - 1] === 0n) {
+    digits.pop();
+  }
+  return digits;
+}