@xyo-network/sdk-protocol 7.0.12 → 7.0.13

package/dist/_pkg/quadkey/neutral/index.mjs

@@ -1,280 +0,0 @@
-// src/Quadkey.ts
-import {
-  assertEx,
-  hexFromArrayBuffer,
-  hexFromHexString
-} from "@ariestools/sdk";
-import {
-  boundingBoxToCenter,
-  GeoJson,
-  MercatorLngLat,
-  tileFromPoint,
-  tileFromQuadkey,
-  tilesFromBoundingBox,
-  tileToBoundingBox,
-  tileToQuadkey
-} from "@xylabs/geo";
-
-// src/RelativeDirectionConstantLookup.ts
-var RelativeDirectionConstantLookup = {
-  e: 1,
-  n: -2,
-  s: 2,
-  w: -1
-};
-
-// src/Quadkey.ts
-var MAX_ZOOM = 124;
-var isQuadkey = (obj) => obj?.type === Quadkey.type;
-var FULL_MASK = 2n ** 256n - 1n;
-var ZOOM_MASK = 0xFFn << 248n;
-var ID_MASK = ZOOM_MASK ^ FULL_MASK;
-var assertMaxBitUint = (value, bits = 256n) => {
-  assertEx(value < 2n ** bits && value >= 0, () => "Not a 256 Bit Uint!");
-};
-function gridOffsetForDigit(digit, blockSize) {
-  switch (digit) {
-    case "1": {
-      return { left: blockSize, top: 0 };
-    }
-    case "2": {
-      return { left: 0, top: blockSize };
-    }
-    case "3": {
-      return { left: blockSize, top: blockSize };
-    }
-    default: {
-      return { left: 0, top: 0 };
-    }
-  }
-}
-var Quadkey = class _Quadkey {
-  static Zero = _Quadkey.from(0, 0n);
-  static root = new _Quadkey();
-  static type = "Quadkey";
-  _geoJson;
-  key;
-  type = _Quadkey.type;
-  constructor(key = 0n) {
-    assertMaxBitUint(key);
-    this.key = key;
-    this.guessZoom();
-  }
-  static from(zoom, id) {
-    const quadkey = new _Quadkey();
-    return quadkey.setId(id).setZoom(zoom);
-  }
-  static fromArrayBuffer(zoom, id) {
-    const quadkey = new _Quadkey();
-    return quadkey.setId(BigInt(hexFromArrayBuffer(id, { prefix: true }))).setZoom(zoom);
-  }
-  static fromBase16String(value) {
-    return new _Quadkey(BigInt(hexFromHexString(value, { prefix: true })));
-  }
-  static fromBase4String(value) {
-    if (value === void 0 || ["fhr", ""].includes(value)) {
-      return this.root;
-    }
-    let id = 0n;
-    for (const digit of value) {
-      const nibble = Number.parseInt(digit);
-      assertEx(nibble < 4 && nibble >= 0, () => `Invalid Base4 String: ${value}`);
-      id = id << 2n | BigInt(nibble);
-    }
-    const quadkey = new _Quadkey();
-    return quadkey.setId(id).setZoom(value.length);
-  }
-  static fromBoundingBox(boundingBox, zoom) {
-    const tiles = tilesFromBoundingBox(boundingBox, Math.floor(zoom));
-    return Array.from(tiles, (tile) => assertEx(this.fromTile(tile), () => "Bad Quadkey"));
-  }
-  static fromLngLat(point, zoom) {
-    const tile = tileFromPoint(point, zoom);
-    const quadkeyString = tileToQuadkey(tile);
-    return this.fromBase4String(quadkeyString);
-  }
-  static fromString(zoom, id, base = 16) {
-    switch (base) {
-      case 16: {
-        return this.fromBase16String(id).setZoom(zoom);
-      }
-      default: {
-        throw new Error(`Invalid base [${base}]`);
-      }
-    }
-  }
-  static fromTile(tile) {
-    return this.fromBase4String(tileToQuadkey(tile));
-  }
-  get base10String() {
-    return this.id.toString(10);
-  }
-  get base16String() {
-    return this.id.toString(16).padStart(62, "0");
-  }
-  get base4Hash() {
-    if (this.id === 0n && this.zoom === 0) {
-      return "";
-    }
-    return this.id.toString(4).padStart(this.zoom, "0");
-  }
-  get base4HashLabel() {
-    const hash = this.base4Hash;
-    return hash.length === 0 ? "fhr" : hash;
-  }
-  get boundingBox() {
-    return tileToBoundingBox(this.tile);
-  }
-  get center() {
-    const result = boundingBoxToCenter(this.boundingBox);
-    return new MercatorLngLat(result[0], result[1]);
-  }
-  get children() {
-    assertEx(this.zoom < MAX_ZOOM - 1, () => "Can not get children of bottom tiles");
-    const result = [];
-    const shiftedId = this.id << 2n;
-    for (let i = 0n; i < 4n; i++) {
-      const quadkey = new _Quadkey();
-      result.push(quadkey.setId(shiftedId | i).setZoom(this.zoom + 1));
-    }
-    return result;
-  }
-  get gridLocation() {
-    const tileData = tileFromQuadkey(this.base4Hash);
-    return {
-      col: 2 ** tileData[2] - tileData[1] - 1,
-      row: tileData[0],
-      zoom: tileData[2]
-    };
-  }
-  get id() {
-    return this.key & ID_MASK;
-  }
-  get parent() {
-    if (this.zoom <= 0) {
-      return;
-    }
-    const quadkey = new _Quadkey();
-    return quadkey.setId(this.id >> 2n).setZoom(this.zoom - 1);
-  }
-  get siblings() {
-    const siblings = assertEx(this.parent?.children, () => `siblings: parentChildren ${this.base4Hash}`);
-    const filteredSiblings = siblings.filter((quadkey) => quadkey.key !== this.key);
-    assertEx(filteredSiblings.length === 3, () => `siblings: expected 3 [${filteredSiblings.length}]`);
-    return filteredSiblings;
-  }
-  get tile() {
-    return tileFromQuadkey(this.base4Hash);
-  }
-  get valid() {
-    return this.id.toString(4) === this.base4Hash.padStart(64, "0");
-  }
-  get zoom() {
-    return Number((this.key & ZOOM_MASK) >> 248n);
-  }
-  childrenByZoom(zoom) {
-    if (zoom > 0 && zoom === this.zoom) {
-      return [this];
-    }
-    let deepResult = [];
-    for (const quadkey of this.children) {
-      deepResult = [...deepResult, ...quadkey.childrenByZoom(zoom)];
-    }
-    return deepResult;
-  }
-  clone() {
-    return new _Quadkey(this.key);
-  }
-  equals(obj) {
-    return obj.key == this.key;
-  }
-  geoJson() {
-    this._geoJson = this._geoJson ?? new GeoJson(this.base4Hash);
-    return this._geoJson;
-  }
-  getGridBoundingBox(size) {
-    const hash = this.base4Hash;
-    let index = 0;
-    let left = 0;
-    let top = 0;
-    let blockSize = size;
-    while (index < hash.length) {
-      blockSize >>= 1;
-      const offset = gridOffsetForDigit(hash[index], blockSize);
-      left += offset.left;
-      top += offset.top;
-      index++;
-    }
-    if (blockSize < 2) {
-      blockSize = 2;
-    }
-    return {
-      height: blockSize,
-      left,
-      top,
-      width: blockSize
-    };
-  }
-  /** @deprecated use .gridLocation instead */
-  getGridLocation() {
-    return this.gridLocation;
-  }
-  isInBoundingBox(boundingBox) {
-    const tileBoundingBox = tileToBoundingBox(this.tile);
-    return boundingBox.contains(tileBoundingBox.getNorthEast()) || boundingBox.contains(tileBoundingBox.getNorthWest()) || boundingBox.contains(tileBoundingBox.getSouthEast()) || boundingBox.contains(tileBoundingBox.getSouthWest());
-  }
-  relative(direction) {
-    const directionConstant = assertEx(RelativeDirectionConstantLookup[direction], () => "Invalid direction");
-    let quadkey = this.base4Hash;
-    if (quadkey.length === 0) {
-      return this;
-    }
-    let index = quadkey.length - 1;
-    while (index >= 0) {
-      let number = Number.parseInt(quadkey.charAt(index));
-      number += directionConstant;
-      if (number > 3) {
-        number -= 4;
-        quadkey = quadkey.slice(0, Math.max(0, index)) + number.toString() + quadkey.slice(Math.max(0, index + 1));
-        index--;
-      } else if (number < 0) {
-        number += 4;
-        quadkey = quadkey.slice(0, Math.max(0, index)) + number.toString() + quadkey.slice(Math.max(0, index + 1));
-        index--;
-      } else {
-        index = -1;
-      }
-    }
-    return _Quadkey.fromBase4String(quadkey);
-  }
-  setId(id) {
-    assertMaxBitUint(id, 248n);
-    this.setKey(this.zoom, id);
-    return this;
-  }
-  setKey(zoom, key) {
-    assertMaxBitUint(key);
-    this.key = key;
-    this.setZoom(zoom);
-    return this;
-  }
-  setZoom(zoom) {
-    assertEx(zoom < MAX_ZOOM, () => `Invalid zoom [${zoom}] max=${MAX_ZOOM}`);
-    this.key = this.key & ID_MASK | BigInt(zoom) << 248n;
-    return this;
-  }
-  toJSON() {
-    return this.base4HashLabel;
-  }
-  toString() {
-    return this.base4Hash;
-  }
-  guessZoom() {
-    const quadkeySimple = this.id.toString(4);
-    this.setZoom(quadkeySimple.length);
-  }
-};
-export {
-  Quadkey,
-  isQuadkey
-};

package/dist/_pkg/quant-account/neutral/QuantAccount.d.ts

@@ -1,33 +0,0 @@
-import type { Hash } from '@ariestools/sdk';
-import type { AccountAlgorithm, AccountConfig, AccountInstance, SignJwtOptions, SignJwtResult } from '../../account-model/neutral/index.ts';
-import type { XyoAddress } from '../../address/neutral/index.ts';
-import type { PreviousHashStore } from '../../previous-hash-store-model/neutral/index.ts';
-export declare class QuantAccount implements AccountInstance {
-    static previousHashStore: PreviousHashStore | undefined;
-    protected static _addressMap: Record<string, WeakRef<AccountInstance>>;
-    protected static _protectedConstructorKey: symbol;
-    private readonly _address;
-    private readonly _addressBytes;
-    private readonly _signingMutex;
-    protected _previousHash?: ArrayBufferLike;
-    protected readonly _publicKey: Uint8Array;
-    protected readonly _secretKey: Uint8Array;
-    readonly algorithm: AccountAlgorithm;
-    protected constructor(key: unknown, secretKey: Uint8Array, publicKey: Uint8Array);
-    static create(opts?: AccountConfig): Promise<AccountInstance>;
-    static fromPrivateKey(key: ArrayBufferLike | bigint | string): Promise<AccountInstance>;
-    static isAddress(address: string): boolean;
-    static random(): Promise<AccountInstance>;
-    get address(): XyoAddress;
-    get addressBytes(): ArrayBufferLike;
-    get previousHash(): Hash | undefined;
-    set previousHash(_value: Hash | undefined);
-    get previousHashBytes(): ArrayBufferLike | undefined;
-    set previousHashBytes(_value: ArrayBufferLike | undefined);
-    get publicKey(): ArrayBufferLike;
-    loadPreviousHash(previousHash?: ArrayBufferLike | string): Promise<this>;
-    sign(hash: ArrayBufferLike, previousHash?: ArrayBufferLike): Promise<[ArrayBufferLike, Hash?]>;
-    signJwt(_options: SignJwtOptions): Promise<SignJwtResult>;
-    verify(msg: ArrayBufferLike, signature: ArrayBufferLike): Promise<boolean>;
-    verifyUniqueAddress(): AccountInstance;
-}

package/dist/_pkg/quant-account/neutral/index.d.ts

@@ -1,2 +0,0 @@
-import './register.ts';
-export * from './QuantAccount.ts';

package/dist/_pkg/quant-account/neutral/index.mjs

@@ -1,172 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/register.ts
-import { addressTo20Bytes, registerVerifier } from "../../account-model/neutral/index.mjs";
-import { MlDsa } from "../../pqc/neutral/index.mjs";
-function buffersEqual(a, b) {
-  if (a.byteLength !== b.byteLength) return false;
-  const a1 = new Uint8Array(a);
-  const a2 = new Uint8Array(b);
-  for (let i = 0; i < a1.byteLength; i++) {
-    if (a1[i] !== a2[i]) return false;
-  }
-  return true;
-}
-registerVerifier("ml-dsa-65", async (address, hash, signatureBundle) => {
-  const { publicKey, signature } = MlDsa.unbundle(signatureBundle);
-  const expectedAddress = addressTo20Bytes(address);
-  const derivedAddress = MlDsa.addressFromPublicKey(publicKey);
-  if (!buffersEqual(expectedAddress, derivedAddress)) {
-    return false;
-  }
-  return await Promise.resolve(MlDsa.verify(publicKey, hash, signature));
-});
-
-// src/QuantAccount.ts
-import {
-  asHash,
-  assertEx,
-  isDefined,
-  isHash,
-  staticImplements,
-  toArrayBuffer,
-  toHex,
-  toUint8Array
-} from "@ariestools/sdk";
-import { hrpForAlgorithm, isPrivateKeyInitializationConfig } from "../../account-model/neutral/index.mjs";
-import { encodeQuantAddress, tryDecodeQuantAddress } from "../../address/neutral/index.mjs";
-import { MlDsa as MlDsa2 } from "../../pqc/neutral/index.mjs";
-import { Mutex } from "async-mutex";
-var QuantAccount = class {
-  _address;
-  _addressBytes;
-  _signingMutex = new Mutex();
-  _previousHash;
-  _publicKey;
-  _secretKey;
-  algorithm = "ml-dsa-65";
-  constructor(key, secretKey, publicKey) {
-    assertEx(key === QuantAccount._protectedConstructorKey, () => "Do not call this protected constructor");
-    this._secretKey = secretKey;
-    this._publicKey = publicKey;
-    this._addressBytes = MlDsa2.addressFromPublicKey(publicKey.buffer);
-    const hrp = assertEx(hrpForAlgorithm("ml-dsa-65"), () => "No HRP registered for algorithm [ml-dsa-65]");
-    this._address = encodeQuantAddress(hrp, this._addressBytes);
-  }
-  static async create(opts) {
-    let seed;
-    if (opts && isPrivateKeyInitializationConfig(opts)) {
-      seed = toUint8Array(opts.privateKey, 32).buffer;
-    }
-    const keyPair = MlDsa2.keygen(seed);
-    const account = new QuantAccount(this._protectedConstructorKey, keyPair.secretKey, keyPair.publicKey);
-    await account.loadPreviousHash(opts?.previousHash);
-    return account.verifyUniqueAddress();
-  }
-  static async fromPrivateKey(key) {
-    const privateKey = toUint8Array(key, 32).buffer;
-    return await this.create({ privateKey });
-  }
-  static isAddress(address) {
-    return tryDecodeQuantAddress(address)?.hrp === hrpForAlgorithm("ml-dsa-65");
-  }
-  static async random() {
-    return await this.create();
-  }
-  get address() {
-    return this._address;
-  }
-  get addressBytes() {
-    return this._addressBytes;
-  }
-  get previousHash() {
-    return this.previousHashBytes ? toHex(this.previousHashBytes, { prefix: false }).toLowerCase() : void 0;
-  }
-  set previousHash(_value) {
-  }
-  get previousHashBytes() {
-    return this._previousHash;
-  }
-  set previousHashBytes(_value) {
-  }
-  get publicKey() {
-    return this._publicKey.buffer;
-  }
-  async loadPreviousHash(previousHash) {
-    return await this._signingMutex.runExclusive(async () => {
-      if (isDefined(previousHash)) {
-        this._previousHash = toUint8Array(previousHash, 32).buffer;
-      } else {
-        const storeValue = await QuantAccount.previousHashStore?.getItem(this.address);
-        if (isHash(storeValue)) {
-          this._previousHash = toUint8Array(storeValue, 32).buffer;
-        }
-      }
-      return this;
-    });
-  }
-  async sign(hash, previousHash) {
-    return await this._signingMutex.runExclusive(async () => {
-      if (QuantAccount.previousHashStore) {
-        const stored = await QuantAccount.previousHashStore.getItem(this.address);
-        this._previousHash = isHash(stored) ? toArrayBuffer(stored, 32) : void 0;
-      }
-      const currentPreviousHash = this.previousHash;
-      const passedCurrentHash = previousHash === void 0 ? this.previousHash : toHex(previousHash, { prefix: false });
-      assertEx(
-        currentPreviousHash === passedCurrentHash,
-        () => `Used and current previous hashes do not match [${currentPreviousHash} !== ${passedCurrentHash}]`
-      );
-      const rawSig = MlDsa2.sign(this._secretKey.buffer, hash);
-      const bundle = MlDsa2.bundle(this._publicKey.buffer, rawSig);
-      const newPreviousHash = toUint8Array(hash, 32).buffer;
-      this._previousHash = newPreviousHash;
-      if (QuantAccount.previousHashStore) {
-        await QuantAccount.previousHashStore.setItem(this.address, asHash(toHex(newPreviousHash, { prefix: false }), true));
-      }
-      return [bundle, currentPreviousHash];
-    });
-  }
-  async signJwt(_options) {
-    return await Promise.reject(new Error("JWT signing is not implemented for ml-dsa-65 (no standard IANA JOSE alg yet)"));
-  }
-  async verify(msg, signature) {
-    if (signature.byteLength === MlDsa2.bundleLength) {
-      const { publicKey, signature: sig } = MlDsa2.unbundle(signature);
-      return await Promise.resolve(MlDsa2.verify(publicKey, msg, sig));
-    }
-    if (signature.byteLength === MlDsa2.signatureLength) {
-      return await Promise.resolve(MlDsa2.verify(this._publicKey.buffer, msg, signature));
-    }
-    return await Promise.resolve(false);
-  }
-  verifyUniqueAddress() {
-    const address = this.address;
-    const existing = QuantAccount._addressMap[address]?.deref();
-    if (existing === void 0) {
-      QuantAccount._addressMap[address] = new WeakRef(this);
-      return this;
-    }
-    return existing;
-  }
-};
-__publicField(QuantAccount, "previousHashStore");
-__publicField(QuantAccount, "_addressMap", {});
-__publicField(QuantAccount, "_protectedConstructorKey", /* @__PURE__ */ Symbol());
-QuantAccount = __decorateClass([
-  staticImplements()
-], QuantAccount);
-export {
-  QuantAccount
-};

package/dist/_pkg/quant-account/neutral/register.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/_pkg/quant-wallet/neutral/QuantHDWallet.d.ts

@@ -1,46 +0,0 @@
-import type { Hash, Hex } from '@ariestools/sdk';
-import type { AccountAlgorithm, AccountConfig, AccountInstance, SignJwtOptions, SignJwtResult } from '../../account-model/neutral/index.ts';
-import type { XyoAddress } from '../../address/neutral/index.ts';
-import type { WalletInstance } from '../../wallet-model/neutral/index.ts';
-import { HDNodeWallet, Mnemonic } from 'ethers';
-export declare class QuantHDWallet implements WalletInstance {
-    private static _protectedConstructorKey;
-    private static _walletAddressMap;
-    readonly algorithm: AccountAlgorithm;
-    protected readonly _account: AccountInstance;
-    protected readonly _master: HDNodeWallet | undefined;
-    protected readonly _seed: Uint8Array;
-    protected readonly node: HDNodeWallet;
-    neuter: () => WalletInstance;
-    protected constructor(key: unknown, node: HDNodeWallet, master: HDNodeWallet | undefined, seed: Uint8Array, account: AccountInstance);
-    static create(opts?: AccountConfig): Promise<WalletInstance>;
-    protected static createFromNode(node: HDNodeWallet, master?: HDNodeWallet, previousHash?: string): Promise<WalletInstance>;
-    static fromExtendedKey(key: string): Promise<WalletInstance>;
-    static fromMnemonic(mnemonic: Mnemonic, path?: string): Promise<WalletInstance>;
-    static fromPhrase(phrase: string, path?: string): Promise<WalletInstance>;
-    static fromPrivateKey(_key: ArrayBufferLike | bigint | string): Promise<AccountInstance>;
-    static fromSeed(seed: string | ArrayBufferLike): Promise<WalletInstance>;
-    static generateMnemonic(wordlist?: string[], strength?: number): string;
-    static random(): Promise<WalletInstance>;
-    get address(): XyoAddress;
-    get addressBytes(): ArrayBufferLike;
-    get chainCode(): string;
-    get depth(): number;
-    get extendedKey(): string;
-    get fingerprint(): string;
-    get index(): number;
-    get mnemonic(): Mnemonic | null;
-    get parentFingerprint(): string;
-    get path(): string | null;
-    get previousHash(): Hash | undefined;
-    set previousHash(_value: Hash | undefined);
-    get previousHashBytes(): ArrayBufferLike | undefined;
-    set previousHashBytes(_value: ArrayBufferLike | undefined);
-    get privateKey(): Hex;
-    get publicKey(): Hex;
-    derivePath(path: string): Promise<WalletInstance>;
-    sign(hash: ArrayBufferLike, previousHash?: ArrayBufferLike): Promise<[ArrayBufferLike, Hash?]>;
-    signJwt(options: SignJwtOptions): Promise<SignJwtResult>;
-    verify(msg: ArrayBufferLike, signature: ArrayBufferLike): Promise<boolean>;
-    verifyUniqueWallet(): WalletInstance;
-}

package/dist/_pkg/quant-wallet/neutral/bip85.d.ts

@@ -1,9 +0,0 @@
-import type { HDNodeWallet } from 'ethers';
-export declare const BIP85_PURPOSE = "83696968'";
-export declare const BIP85_HEX_APP = "128169'";
-export declare const BIP85_HMAC_KEY = "bip-entropy-from-k";
-export declare const BIP85_SEED_LENGTH = 32;
-export declare function bip85DefaultLeafTail(index?: number): string;
-export declare function isBip85AbsolutePath(path: string): boolean;
-export declare function isUnderBip85Purpose(node: HDNodeWallet): boolean;
-export declare function bip85EntropyFromNode(node: HDNodeWallet): Uint8Array;

package/dist/_pkg/quant-wallet/neutral/index.d.ts

@@ -1,2 +0,0 @@
-export * from './bip85.ts';
-export * from './QuantHDWallet.ts';