@silvana-one/coordination 1.0.15

package/src/base58/bigint-helpers.ts

@@ -0,0 +1,236 @@
+export {
+  changeBase,
+  bytesToBigInt,
+  bigIntToBytes,
+  bigIntToBits,
+  parseHexString32,
+  log2,
+  max,
+  abs,
+  sign,
+  bytesToBigint32,
+  bigintToBytes32,
+};
+
+function bytesToBigint32(bytes: Uint8Array) {
+  let words = new BigUint64Array(bytes.buffer, bytes.byteOffset, 4);
+  return words[0] | (words[1] << 64n) | (words[2] << 128n) | (words[3] << 192n);
+}
+
+const mask64 = (1n << 64n) - 1n;
+
+function bigintToBytes32(x: bigint, bytes: Uint8Array): Uint8Array {
+  let words = new BigUint64Array(bytes.buffer, bytes.byteOffset, 4);
+  words[0] = x & mask64;
+  words[1] = (x >> 64n) & mask64;
+  words[2] = (x >> 128n) & mask64;
+  words[3] = x >> 192n;
+  return bytes;
+}
+
+function bytesToBigInt(bytes: Uint8Array | number[]) {
+  let x = 0n;
+  let bitPosition = 0n;
+  for (let byte of bytes) {
+    x += BigInt(byte) << bitPosition;
+    bitPosition += 8n;
+  }
+  return x;
+}
+
+let hexToNum: { [hexCharCode: number]: number } = {};
+for (let i = 0; i < 16; i++) hexToNum[i.toString(16).charCodeAt(0)] = i;
+let encoder = new TextEncoder();
+
+const tmpBytes = new Uint8Array(64);
+
+function parseHexString32(input: string) {
+  // Parse the bytes explicitly, Bigint endianness is wrong
+  encoder.encodeInto(input, tmpBytes);
+  for (let j = 0; j < 32; j++) {
+    let n1 = hexToNum[tmpBytes[2 * j]];
+    let n0 = hexToNum[tmpBytes[2 * j + 1]];
+    tmpBytes[j] = (n1 << 4) | n0;
+  }
+  return bytesToBigint32(tmpBytes);
+}
+
+/**
+ * Transforms bigint to little-endian array of bytes (numbers between 0 and 255) of a given length.
+ * Throws an error if the bigint doesn't fit in the given number of bytes.
+ */
+function bigIntToBytes(x: bigint, length?: number) {
+  if (x < 0n) {
+    throw Error(`bigIntToBytes: negative numbers are not supported, got ${x}`);
+  }
+  if (length === undefined) return bigintToBytesFlexible(x);
+  let bytes: number[] = Array(length);
+  for (let i = 0; i < length; i++, x >>= 8n) {
+    bytes[i] = Number(x & 0xffn);
+  }
+  if (x > 0n) {
+    throw Error(`bigIntToBytes: input does not fit in ${length} bytes`);
+  }
+  return bytes;
+}
+
+function bigintToBytesFlexible(x: bigint) {
+  let bytes: number[] = [];
+  for (; x > 0n; x >>= 8n) {
+    bytes.push(Number(x & 0xffn));
+  }
+  return bytes;
+}
+
+/**
+ * Transforms bigint to little-endian array of bits (booleans).
+ * The length of the bit array is determined as needed.
+ */
+function bigIntToBits(x: bigint) {
+  if (x < 0n) {
+    throw Error(`bigIntToBits: negative numbers are not supported, got ${x}`);
+  }
+  let bits: boolean[] = [];
+  for (; x > 0n; x >>= 1n) {
+    let bit = !!(x & 1n);
+    bits.push(bit);
+  }
+  return bits;
+}
+
+function changeBase(digits: bigint[], base: bigint, newBase: bigint) {
+  // 1. accumulate digits into one gigantic bigint `x`
+  let x = fromBase(digits, base);
+  // 2. compute new digits from `x`
+  let newDigits = toBase(x, newBase);
+  return newDigits;
+}
+
+/**
+ * the algorithm for toBase / fromBase is more complicated than it naively has to be,
+ * but that is for performance reasons.
+ *
+ * we'll explain it for `fromBase`. this function is about taking an array of digits
+ * `[x0, ..., xn]`
+ * and returning the integer (bigint) that has those digits in the given `base`:
+ * ```
+ * let x = x0 + x1*base + x2*base**2 + ... + xn*base**n
+ * ```
+ *
+ * naively, we could just accumulate digits from left to right:
+ * ```
+ * let x = 0n;
+ * let p = 1n;
+ * for (let i=0; i<n; i++) {
+ *   x += X[i] * p;
+ *   p *= base;
+ * }
+ * ```
+ *
+ * in the ith step, `p = base**i` which is multiplied with `xi` and added to the sum.
+ * however, note that this algorithm is `O(n^2)`: let `l = log2(base)`. the base power `p` is a bigint of bit length `i*l`,
+ * which is multiplied by a "small" number `xi` (length l), which takes `O(i)` time in every step.
+ * since this is done for `i = 0,...,n`, we end up with an `O(n^2)` algorithm.
+ *
+ * HOWEVER, it turns out that there are fast multiplication algorithms, and JS bigints have them built in!
+ * the Schönhage-Strassen algorithm (implemented in the V8 engine, see https://github.com/v8/v8/blob/main/src/bigint/mul-fft.cc)
+ * can multiply two n-bit numbers in time `O(n log(n) loglog(n))`, when n is large.
+ *
+ * to take advantage of asymptotically fast multiplication, we need to re-structure our algorithm such that it multiplies roughly equal-sized
+ * numbers with each other (there is no asymptotic boost for multiplying a small with a large number). so, what we do is to go from the
+ * original digit array to arrays of successively larger digits:
+ * ```
+ * step 0:                  step 1:                              step 2:
+ * [x0, x1, x2, x3, ...] -> [x0 + base*x1, x2 + base*x3, ...] -> [x0 + base*x1 + base^2*(x2 + base*x3), ...] -> ...
+ * ```
+ *
+ * ...until after a log(n) number of steps we end up with a single "digit" which is equal to the entire sum.
+ *
+ * in the ith step, we multiply `n/2^i` pairs of numbers of bit length `2^i*l`. each of these multiplications takes
+ * time `O(2^i log(2^i) loglog(2^i))`. if we bound that with `O(2^i log(n) loglog(n))`, we get a runtime bounded by
+ * ```
+ * O(n/2^i * 2^i log(n) loglog(n)) = O(n log(n) loglog(n))
+ * ```
+ * in each step. Since we have `log(n)` steps, the result is `O(n log(n)^2 loglog(n))`.
+ *
+ * empirically, this method is a huge improvement over the naive `O(n^2)` algorithm and scales much better with n (the number of digits).
+ *
+ * similar conclusions hold for `toBase`.
+ */
+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;
+}
+
+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;
+}
+
+/**
+ * ceil(log2(n))
+ * = smallest k such that n <= 2^k
+ */
+function log2(n: number | bigint) {
+  if (typeof n === "number") n = BigInt(n);
+  if (n === 1n) return 0;
+  return (n - 1n).toString(2).length;
+}
+
+function max(a: bigint, b: bigint) {
+  return a > b ? a : b;
+}
+
+function abs(x: bigint) {
+  return x < 0n ? -x : x;
+}
+
+function sign(x: bigint): 1n | -1n {
+  return x >= 0 ? 1n : -1n;
+}

package/src/base58/index.ts

@@ -0,0 +1,2 @@
+export * from "./signature.js";
+export * from "./public-key.js";

package/src/base58/public-key.ts

@@ -0,0 +1,13 @@
+import { toBase58Check, toBytesWithVersionNumber } from "./base58.js";
+import { versionNumbers, versionBytes } from "./versions.js";
+
+export function convertFieldsToPublicKey(fields: {
+  x: bigint;
+  isOdd: boolean;
+}): string {
+  let bytes = toBytesWithVersionNumber(
+    [fields.x, fields.isOdd ? 1n : 0n],
+    versionNumbers.publicKey
+  );
+  return toBase58Check(bytes, versionBytes.publicKey);
+}

package/src/base58/signature.ts

@@ -0,0 +1,89 @@
+import { MinaSignature } from "../types.js";
+import { fromBase58Check, toBase58Check } from "./base58.js";
+import { versionNumbers, versionBytes } from "./versions.js";
+
+type NonNegativeInteger<T extends number> = number extends T
+  ? never
+  : `${T}` extends `-${string}` | `${string}.${string}` | `${string}e-${string}`
+  ? never
+  : T;
+
+function assertNonNegativeInteger(n: number, message: string) {
+  if (!Number.isInteger(n) || n < 0) throw Error(message);
+}
+
+function bytesToBigInt(bytes: number[]) {
+  let x = 0n;
+  let bitPosition = 0n;
+  for (let byte of bytes) {
+    x += BigInt(byte) << bitPosition;
+    bitPosition += 8n;
+  }
+  return x;
+}
+
+function readBytesInternal(bytes: number[], start: number) {
+  const rBytes = bytes.slice(start, start + 32);
+  const sBytes = bytes.slice(start + 32, start + 64);
+  const r = bytesToBigInt(rBytes);
+  const s = bytesToBigInt(sBytes);
+  return { r, s };
+}
+
+function readBytes(bytes: number[], offset: number, versionNumber: number) {
+  let version = bytes[offset++];
+  if (version !== versionNumber) {
+    throw Error(
+      `fromBytes: Invalid version byte. Expected ${versionNumber}, got ${version}.`
+    );
+  }
+  return readBytesInternal(bytes, offset);
+}
+
+let readBytes_ = <N extends number>(
+  bytes: number[],
+  offset: NonNegativeInteger<N>
+) => {
+  assertNonNegativeInteger(offset, "readBytes: offset must be integer >= 0");
+  if (offset >= bytes.length)
+    throw Error("readBytes: offset must be within bytes length");
+  return readBytes(bytes, offset, versionNumbers.signature);
+};
+
+function fromBytes(bytes: number[]): MinaSignature {
+  return readBytes_(bytes, 0);
+}
+
+function toBytes(signature: MinaSignature): number[] {
+  const result = new Array<number>(65);
+  result[0] = versionNumbers.signature;
+
+  // Convert r to bytes
+  let r = signature.r;
+  for (let i = 0; i < 32; i++) {
+    result[i + 1] = Number(r & 0xffn);
+    r >>= 8n;
+  }
+
+  // Convert s to bytes
+  let s = signature.s;
+  for (let i = 0; i < 32; i++) {
+    result[i + 33] = Number(s & 0xffn);
+    s >>= 8n;
+  }
+
+  return result;
+}
+
+export function convertMinaSignatureFromBase58(
+  signature: string
+): MinaSignature {
+  const bytes = fromBase58Check(signature, versionBytes.signature);
+  const minaSignature = fromBytes(bytes);
+  return minaSignature;
+}
+
+export function convertMinaSignatureToBase58(signature: MinaSignature): string {
+  const bytes = toBytes(signature);
+  return toBase58Check(bytes, versionBytes.signature);
+}

package/src/base58/versions.ts

@@ -0,0 +1,12 @@
+export const versionNumbers = {
+  field: 1,
+  scalar: 1,
+  publicKey: 1,
+  signature: 1,
+};
+
+export const versionBytes = {
+  publicKey: 203,
+  privateKey: 90,
+  signature: 154,
+};

package/src/execute.ts

@@ -0,0 +1,176 @@
+import { SuiEvent, SuiTransactionBlockResponse } from "@mysten/sui/client";
+import {
+  ParallelTransactionExecutor,
+  Transaction,
+} from "@mysten/sui/transactions";
+import { Secp256k1Keypair } from "@mysten/sui/keypairs/secp256k1";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import { suiClient } from "./sui-client.js";
+import { nanoid } from "nanoid";
+import { sleep } from "./sleep.js";
+
+const executors: { [key: string]: ParallelTransactionExecutor } = {};
+const locks: { [key: string]: string | undefined } = {};
+
+const LOCK_TIMEOUT = 1000 * 60 * 2; // 5 minutes
+
+async function getLock(address: string): Promise<string | undefined> {
+  const id = nanoid();
+  let locked = false;
+  const start = Date.now();
+  while (!locked && Date.now() - start < LOCK_TIMEOUT) {
+    if (locks[address]) {
+      await sleep(Math.floor(Math.random() * 10) + 10);
+    } else {
+      locks[address] = id;
+      await sleep(10);
+      if (locks[address] === id) {
+        locked = true;
+        return id;
+      }
+    }
+  }
+  return undefined;
+}
+
+async function releaseLock(params: { address: string; id: string }) {
+  const { address, id } = params;
+  if (locks[address] === id) {
+    locks[address] = undefined;
+  }
+}
+
+function getExecutor(keyPair: Secp256k1Keypair | Ed25519Keypair) {
+  const keyPairId = keyPair.toSuiAddress();
+  if (!executors[keyPairId]) {
+    executors[keyPairId] = new ParallelTransactionExecutor({
+      client: suiClient,
+      signer: keyPair,
+      initialCoinBalance: 500_000_000n,
+      minimumCoinBalance: 300_000_000n,
+      maxPoolSize: 5,
+    });
+    locks[keyPairId] = undefined;
+  }
+  return executors[keyPairId];
+}
+
+export async function executeTx(params: {
+  tx: Transaction;
+  keyPair: Secp256k1Keypair | Ed25519Keypair;
+  useParallelExecutor?: boolean;
+  showErrors?: boolean;
+}): Promise<
+  | {
+      tx: SuiTransactionBlockResponse;
+      digest: string;
+      events: object;
+      executeTime: number;
+    }
+  | undefined
+> {
+  let lockId: string | undefined;
+  let address: string | undefined;
+  try {
+    const {
+      tx,
+      keyPair,
+      useParallelExecutor = false,
+      showErrors = true,
+    } = params;
+    let executedTx: SuiTransactionBlockResponse;
+    let start = 0;
+    let end = 0;
+    if (useParallelExecutor) {
+      address = keyPair.toSuiAddress();
+      lockId = await getLock(address);
+      if (!lockId) {
+        throw new Error("Failed to get lock");
+      }
+      start = Date.now();
+      const executor = getExecutor(keyPair);
+      executedTx = (
+        await executor.executeTransaction(tx, {
+          showEffects: true,
+          showObjectChanges: true,
+          showInput: true,
+          showEvents: true,
+          showBalanceChanges: true,
+        })
+      ).data;
+      end = Date.now();
+      await waitTx(executedTx.digest);
+      await sleep(1000);
+      await releaseLock({ address: address, id: lockId });
+    } else {
+      address = keyPair.toSuiAddress();
+      lockId = await getLock(address);
+      if (!lockId) {
+        throw new Error("Failed to get lock");
+      }
+      const signedTx = await tx.sign({
+        signer: keyPair,
+        client: suiClient,
+      });
+      start = Date.now();
+      // const dryRun = await suiClient.devInspectTransactionBlock({
+      //   sender: keypair.toSuiAddress(),
+      //   transactionBlock: signedTx.bytes
+      // });
+      // dryRun.effects.gasUsed.computationCost
+      // const gasPrice = await suiClient.getReferenceGasPrice();
+
+      executedTx = await suiClient.executeTransactionBlock({
+        transactionBlock: signedTx.bytes,
+        signature: signedTx.signature,
+        options: {
+          showEffects: true,
+          showObjectChanges: true,
+          showInput: true,
+          showEvents: true,
+          showBalanceChanges: true,
+        },
+      });
+      end = Date.now();
+      await releaseLock({ address, id: lockId });
+    }
+
+    if (executedTx?.effects?.status?.status === "failure") {
+      if (showErrors) {
+        console.log(
+          `Errors for tx ${executedTx.digest}:`,
+          executedTx?.effects?.status?.error
+        );
+        throw new Error(`tx execution failed: ${executedTx.digest}`);
+      }
+    }
+    return {
+      tx: executedTx,
+      digest: executedTx.digest,
+      events: (executedTx?.events as SuiEvent[])?.[0]?.parsedJson as object,
+      executeTime: end - start,
+    };
+  } catch (error: any) {
+    if (lockId && address) {
+      await releaseLock({ address, id: lockId });
+    }
+    console.error("Error in executeTx", error.message);
+    return undefined;
+  }
+}
+
+export async function waitTx(digest: string) {
+  console.time(`wait sui tx`);
+  const txWaitResult = await suiClient.waitForTransaction({
+    digest,
+    options: {
+      showEffects: true,
+      showObjectChanges: true,
+      showInput: true,
+      showEvents: true,
+      showBalanceChanges: true,
+    },
+  });
+  console.timeEnd(`wait sui tx`);
+  return txWaitResult;
+}

package/src/fetch.ts

@@ -0,0 +1,54 @@
+import { suiClient } from "./sui-client.js";
+
+export async function fetchSuiObject(objectID: string) {
+  const data = await suiClient.getObject({
+    id: objectID,
+    options: {
+      showContent: true,
+    },
+  });
+  return data;
+}
+
+export async function fetchSuiDynamicField(params: {
+  objectID?: string;
+  parentID?: string;
+  fieldName: string;
+  type: string;
+  key: string;
+}): Promise<object | undefined> {
+  try {
+    const { objectID, parentID, fieldName, type, key } = params;
+
+    if (!objectID && !parentID) {
+      console.error("objectID or parentID is required");
+      return undefined;
+    }
+    let id = parentID;
+    if (objectID && !parentID) {
+      const suiObject = (await fetchSuiObject(objectID)) as any;
+
+      id = (suiObject?.data?.content?.fields?.[fieldName] as any)?.fields?.id
+        ?.id;
+    }
+    if (!id) {
+      return undefined;
+    }
+
+    const field = await suiClient.getDynamicFieldObject({
+      parentId: id,
+      name: {
+        type,
+        value: key,
+      },
+    });
+
+    return (field.data?.content as any)?.fields as object;
+  } catch (error: any) {
+    console.error(
+      "fetchSuiDynamicField: Error fetching dynamic field",
+      error?.message
+    );
+    return undefined;
+  }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from "./base58/index.js";
+export * from "./execute.js";
+export * from "./publish.js";
+export * from "./sui-client.js";
+export * from "./sleep.js";
+export * from "./upgrade.js";
+export * from "./mvr.js";
+export * from "./agent.js";
+export * from "./fetch.js";

package/src/mvr.ts

@@ -0,0 +1,99 @@
+import { Transaction } from "@mysten/sui/transactions";
+
+export function publishToMVR(params: {
+  mvrName: string; // e.g. @suins/core
+  upgradeCap: string;
+  packageName: string;
+  safeAddress: string;
+}): Transaction {
+  const { upgradeCap, packageName, mvrName, safeAddress } = params;
+  const transaction = new Transaction();
+
+  const packageInfo = transaction.moveCall({
+    target: `@mvr/metadata::package_info::new`,
+    arguments: [transaction.object(upgradeCap)],
+  });
+
+  // We also need to create the visual representation of our "info" object.
+  // You can also call `@mvr/metadata::display::new` instead,
+  // that allows customizing the colors of your metadata object!
+  const display = transaction.moveCall({
+    target: `@mvr/metadata::display::default`,
+    arguments: [transaction.pure.string(packageName)],
+  });
+
+  // Set that display object to our info object.
+  transaction.moveCall({
+    target: `@mvr/metadata::package_info::set_display`,
+    arguments: [transaction.object(packageInfo), display],
+  });
+
+  // Set the default for the packageInfo, which enables reverse resolution for that network
+  // See details in reverse resolution section
+  transaction.moveCall({
+    target: "@mvr/metadata::package_info::set_metadata",
+    arguments: [
+      transaction.object(packageInfo),
+      transaction.pure.string("default"),
+      transaction.pure.string(mvrName),
+    ],
+  });
+
+  // Optionally unset the metadata for the packageInfo
+  // transaction.moveCall({
+  //     target: "@mvr/metadata::package_info::unset_metadata",
+  //     arguments: [
+  //         transaction.object(packageInfo),
+  //         transaction.pure.string("default"),
+  //     ],
+  // });
+
+  // transfer the `PackageInfo` object to a safe address.
+  transaction.moveCall({
+    target: `@mvr/metadata::package_info::transfer`,
+    arguments: [
+      transaction.object(packageInfo),
+      transaction.pure.address(safeAddress),
+    ],
+  });
+
+  return transaction;
+}
+
+export function publishCodeToMVR(params: {
+  packageInfo: string;
+  gitRepository: string; // e.g. https://github.com/mystenlabs/mvr
+  gitSubdirectory: string; // e.g. packages/mvr
+  gitCommitHash: string; // e.g. 636d22d6bc4195afec9a1c0a8563b61fc813acfc
+  version: number;
+}): Transaction {
+  const {
+    packageInfo,
+    gitRepository,
+    gitSubdirectory,
+    gitCommitHash,
+    version,
+  } = params;
+
+  const transaction = new Transaction();
+
+  const git = transaction.moveCall({
+    target: `@mvr/metadata::git::new`,
+    arguments: [
+      transaction.pure.string(gitRepository),
+      transaction.pure.string(gitSubdirectory),
+      transaction.pure.string(gitCommitHash),
+    ],
+  });
+
+  transaction.moveCall({
+    target: `@mvr/metadata::package_info::set_git_versioning`,
+    arguments: [
+      transaction.object(packageInfo),
+      transaction.pure.u64(version),
+      git,
+    ],
+  });
+
+  return transaction;
+}