@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/previous-hash-store-storage/neutral/index.mjs

@@ -0,0 +1,104 @@
+// src/NamespacedStorage.ts
+var InMemoryBackend = class {
+  data = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.data.get(key) ?? null;
+  }
+  remove(key) {
+    this.data.delete(key);
+  }
+  set(key, value) {
+    this.data.set(key, value);
+  }
+};
+var WebStorageBackend = class {
+  storage;
+  constructor(storage) {
+    this.storage = storage;
+  }
+  get(key) {
+    return this.storage.getItem(key);
+  }
+  remove(key) {
+    this.storage.removeItem(key);
+  }
+  set(key, value) {
+    this.storage.setItem(key, value);
+  }
+};
+var pageBackend = new InMemoryBackend();
+var localBackend;
+var sessionBackend;
+function getBackend(area) {
+  if (area === "page") return pageBackend;
+  const g = globalThis;
+  if (area === "local") {
+    if (localBackend) return localBackend;
+    localBackend = g.localStorage ? new WebStorageBackend(g.localStorage) : new InMemoryBackend();
+    return localBackend;
+  }
+  if (sessionBackend) return sessionBackend;
+  sessionBackend = g.sessionStorage ? new WebStorageBackend(g.sessionStorage) : new InMemoryBackend();
+  return sessionBackend;
+}
+var NamespacedStorage = class {
+  backend;
+  prefix;
+  constructor(area, namespace) {
+    this.backend = getBackend(area);
+    this.prefix = `${namespace}.`;
+  }
+  get(key) {
+    const raw = this.backend.get(this.prefix + key);
+    if (raw === null) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  remove(key) {
+    this.backend.remove(this.prefix + key);
+  }
+  set(key, value) {
+    this.backend.set(this.prefix + key, JSON.stringify(value));
+  }
+};
+
+// src/StoragePreviousHashStore.ts
+var StoragePreviousHashStore = class _StoragePreviousHashStore {
+  static DefaultNamespace = "xyo-previous-hash-store";
+  static DefaultStorageType = "local";
+  _namespace = _StoragePreviousHashStore.DefaultNamespace;
+  _storage;
+  _type = _StoragePreviousHashStore.DefaultStorageType;
+  constructor(opts) {
+    if (typeof opts?.namespace === "string") this._namespace = opts.namespace;
+    if (opts?.type) this._type = opts.type;
+    this._storage = new NamespacedStorage(this.type, this.namespace);
+  }
+  get storage() {
+    this._storage ??= new NamespacedStorage(this.type, this.namespace);
+    return this._storage;
+  }
+  get namespace() {
+    return this._namespace;
+  }
+  get type() {
+    return this._type;
+  }
+  async getItem(address) {
+    return this.storage.get(address) ?? null;
+  }
+  async removeItem(address) {
+    this.storage.remove(address);
+  }
+  async setItem(address, previousHash) {
+    this.storage.set(address, previousHash);
+  }
+};
+export {
+  NamespacedStorage,
+  StoragePreviousHashStore
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/protocol/neutral/index.d.ts

@@ -0,0 +1,5 @@
+export * from '../../boundwitness/neutral/index.ts';
+export * from '../../core/neutral/index.ts';
+export * from '../../crypto/neutral/index.ts';
+export * from '../../payload/neutral/index.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,6 @@
+// src/index.ts
+export * from "../../boundwitness/neutral/index.mjs";
+export * from "../../core/neutral/index.mjs";
+export * from "../../crypto/neutral/index.mjs";
+export * from "../../payload/neutral/index.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/quadkey/neutral/Quadkey.d.ts

@@ -0,0 +1,65 @@
+import type { MercatorBoundingBox, MercatorLngLatLike, MercatorTile } from '@xylabs/geo';
+import { GeoJson, MercatorLngLat } from '@xylabs/geo';
+export declare const isQuadkey: (obj: {
+    type: string;
+}) => boolean;
+export declare class Quadkey {
+    static readonly Zero: Quadkey;
+    static readonly root: Quadkey;
+    static readonly type = "Quadkey";
+    private _geoJson?;
+    key: bigint;
+    type: string;
+    constructor(key?: bigint);
+    static from(zoom: number, id: bigint): Quadkey;
+    static fromArrayBuffer(zoom: number, id: ArrayBuffer): Quadkey;
+    static fromBase16String(value: string): Quadkey;
+    static fromBase4String(value?: string): Quadkey;
+    static fromBoundingBox(boundingBox: MercatorBoundingBox, zoom: number): Quadkey[];
+    static fromLngLat(point: MercatorLngLatLike, zoom: number): Quadkey;
+    static fromString(zoom: number, id: string, base?: number): Quadkey;
+    static fromTile(tile: MercatorTile): Quadkey;
+    get base10String(): string;
+    get base16String(): string;
+    get base4Hash(): string;
+    get base4HashLabel(): string;
+    get boundingBox(): MercatorBoundingBox;
+    get center(): MercatorLngLat;
+    get children(): Quadkey[];
+    get gridLocation(): {
+        col: number;
+        row: number;
+        zoom: number;
+    };
+    get id(): bigint;
+    get parent(): Quadkey | undefined;
+    get siblings(): Quadkey[];
+    get tile(): MercatorTile;
+    get valid(): boolean;
+    get zoom(): number;
+    childrenByZoom(zoom: number): Quadkey[];
+    clone(): Quadkey;
+    equals(obj: Quadkey): boolean;
+    geoJson(): GeoJson;
+    getGridBoundingBox(size: number): {
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+    };
+    /** @deprecated use .gridLocation instead */
+    getGridLocation(): {
+        col: number;
+        row: number;
+        zoom: number;
+    };
+    isInBoundingBox(boundingBox: MercatorBoundingBox): boolean;
+    relative(direction: string): Quadkey;
+    setId(id: bigint): this;
+    setKey(zoom: number, key: bigint): this;
+    setZoom(zoom: number): this;
+    toJSON(): string;
+    toString(): string;
+    protected guessZoom(): void;
+}
+//# sourceMappingURL=Quadkey.d.ts.map

package/dist/_pkg/quadkey/neutral/RelativeDirectionConstantLookup.d.ts

@@ -0,0 +1,2 @@
+export declare const RelativeDirectionConstantLookup: Record<string, number>;
+//# sourceMappingURL=RelativeDirectionConstantLookup.d.ts.map

package/dist/_pkg/quadkey/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Quadkey.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,281 @@
+// src/Quadkey.ts
+import {
+  boundingBoxToCenter,
+  GeoJson,
+  MercatorLngLat,
+  tileFromPoint,
+  tileFromQuadkey,
+  tilesFromBoundingBox,
+  tileToBoundingBox,
+  tileToQuadkey
+} from "@xylabs/geo";
+import {
+  assertEx,
+  hexFromArrayBuffer,
+  hexFromHexString
+} from "@xylabs/sdk";
+
+// 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
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,34 @@
+import type { Hash } from '@xylabs/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;
+}
+//# sourceMappingURL=QuantAccount.d.ts.map

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

@@ -0,0 +1,3 @@
+import './register.ts';
+export * from './QuantAccount.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,173 @@
+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 "@xylabs/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
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register.d.ts.map