@xyo-network/sdk 7.0.2 → 7.0.4

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

@@ -1,546 +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 { Elliptic } from "../../elliptic/neutral/index.mjs";
-registerVerifier("secp256k1", async (address, hash, signature) => {
-  await Elliptic.initialize();
-  return await Elliptic.verify(hash, signature, addressTo20Bytes(address));
-});
-
-// src/Account.ts
-import {
-  asAddress,
-  asHash,
-  assertEx as assertEx3,
-  globallyUnique,
-  isDefined as isDefined2,
-  isHash,
-  isString,
-  staticImplements as staticImplements4,
-  toArrayBuffer as toArrayBuffer3,
-  toHex as toHex3,
-  toUint8Array as toUint8Array3
-} from "@xylabs/sdk";
-import {
-  isMnemonicInitializationConfig,
-  isPhraseInitializationConfig,
-  isPrivateKeyInitializationConfig
-} from "../../account-model/neutral/index.mjs";
-import { Elliptic as Elliptic5 } from "../../elliptic/neutral/index.mjs";
-import { Mutex } from "async-mutex";
-import {
-  HDNodeWallet,
-  Mnemonic,
-  randomBytes
-} from "ethers";
-
-// src/Jwt/createJwt.ts
-import { toHex } from "@xylabs/sdk";
-import {
-  JwtAlg,
-  JwtSchema,
-  JwtTyp
-} from "../../account-model/neutral/index.mjs";
-
-// src/Jwt/base64url.ts
-import { base64urlnopad } from "@scure/base";
-function base64urlEncode(bytes) {
-  return base64urlnopad.encode(bytes);
-}
-function base64urlDecode(value) {
-  return base64urlnopad.decode(value);
-}
-function base64urlEncodeJson(value) {
-  const encoder = new TextEncoder();
-  return base64urlEncode(encoder.encode(JSON.stringify(value)));
-}
-function base64urlDecodeJson(value) {
-  const decoder = new TextDecoder();
-  return JSON.parse(decoder.decode(base64urlDecode(value)));
-}
-
-// src/Jwt/digest.ts
-import { toUint8Array } from "@xylabs/sdk";
-import { sha256 } from "ethers";
-function sha256Bytes(input) {
-  return toUint8Array(sha256(input));
-}
-function stripHexPrefix(value) {
-  return value.startsWith("0x") ? value.slice(2) : value;
-}
-function normalizeAddress(value) {
-  return stripHexPrefix(value).toLowerCase();
-}
-
-// src/Jwt/createJwt.ts
-function publicKeyHex(account) {
-  const publicKey = account.public;
-  if (!publicKey) throw new Error("Account is missing public key");
-  return toHex(publicKey.bytes, { prefix: false });
-}
-async function createJwt(account, options) {
-  if (!options.audience || options.audience.length === 0) {
-    throw new Error("audience is required");
-  }
-  if (options.ttl !== void 0 && options.exp !== void 0) {
-    throw new Error("Specify only one of ttl or exp");
-  }
-  const now = options.now ?? Math.floor(Date.now() / 1e3);
-  const ttl = options.ttl ?? 3600;
-  const exp = options.exp ?? now + ttl;
-  if (exp <= now) throw new Error(`exp (${exp}) must be greater than now (${now})`);
-  const merged = { ...options.claims };
-  const schemaValue = options.schema ?? (typeof merged.schema === "string" ? merged.schema : JwtSchema.Signin);
-  delete merged.schema;
-  const iss = normalizeAddress(String(account.address));
-  const payload = {
-    ...merged,
-    schema: schemaValue,
-    iss,
-    aud: options.audience,
-    iat: now,
-    exp
-  };
-  const header = {
-    alg: JwtAlg.ES256K,
-    typ: JwtTyp.JWT,
-    kid: iss,
-    pub: publicKeyHex(account)
-  };
-  const headerB64 = base64urlEncodeJson(header);
-  const payloadB64 = base64urlEncodeJson(payload);
-  const encoder = new TextEncoder();
-  const signingInput = encoder.encode(`${headerB64}.${payloadB64}`);
-  const digest = sha256Bytes(signingInput);
-  const digestBuffer = digest.buffer.slice(digest.byteOffset, digest.byteOffset + digest.byteLength);
-  const [sigBuffer] = await account.sign(digestBuffer);
-  const signature = new Uint8Array(sigBuffer);
-  const signatureB64 = base64urlEncode(signature);
-  const token = `${headerB64}.${payloadB64}.${signatureB64}`;
-  return {
-    token,
-    header,
-    payload
-  };
-}
-
-// src/Jwt/decodeJwt.ts
-function decodeJwt(token) {
-  const parts = token.trim().split(".");
-  if (parts.length !== 3) {
-    throw new Error(`Malformed JWT: expected 3 segments, got ${parts.length}`);
-  }
-  const [headerB64, payloadB64, signatureB64] = parts;
-  const header = base64urlDecodeJson(headerB64);
-  const payload = base64urlDecodeJson(payloadB64);
-  const signature = base64urlDecode(signatureB64);
-  return {
-    header,
-    payload,
-    signature,
-    headerB64,
-    payloadB64,
-    signatureB64
-  };
-}
-
-// src/Jwt/verifyJwt.ts
-import { toHex as toHex2, toUint8Array as toUint8Array2 } from "@xylabs/sdk";
-import { JwtAlg as JwtAlg2, JwtTyp as JwtTyp2 } from "../../account-model/neutral/index.mjs";
-
-// src/Key/PublicKey.ts
-import {
-  assertEx,
-  staticImplements as staticImplements2,
-  toArrayBuffer
-} from "@xylabs/sdk";
-import { Elliptic as Elliptic3 } from "../../elliptic/neutral/index.mjs";
-
-// src/Key/AddressValue.ts
-import { isDefined, staticImplements } from "@xylabs/sdk";
-import { Data as Data2 } from "../../data/neutral/index.mjs";
-import { Elliptic as Elliptic2 } from "../../elliptic/neutral/index.mjs";
-
-// src/Key/EllipticKey.ts
-import { Data } from "../../data/neutral/index.mjs";
-var EllipticKey = class extends Data {
-  // we do this to allow node to import without problem
-};
-
-// src/Key/AddressValue.ts
-var AddressValue = class extends EllipticKey {
-  _isAddress = true;
-  constructor(address) {
-    super(20, AddressValue.addressFromAddressOrPublicKey(address));
-  }
-  static addressFromAddressOrPublicKey(bytes) {
-    return bytes.byteLength === 20 ? bytes : this.addressFromPublicKey(bytes);
-  }
-  static addressFromPublicKey(key) {
-    const data = new Data2(64, key);
-    return data.keccak256.slice(12);
-  }
-  static async initialize() {
-    return isDefined(await Elliptic2.secp256k1());
-  }
-  static isAddress(value) {
-    return value._isAddress;
-  }
-};
-AddressValue = __decorateClass([
-  staticImplements()
-], AddressValue);
-
-// src/Key/PublicKey.ts
-var PublicKey = class extends EllipticKey {
-  _address;
-  _isPublicKey = true;
-  constructor(privateConstructorKey, bytes) {
-    assertEx(PublicKey.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
-    super(64, bytes);
-    const address = Elliptic3.addressFromPublicKey(bytes);
-    const addressValue = new AddressValue(address);
-    this._address = addressValue;
-  }
-  static async create(bytes) {
-    return await Promise.resolve(new PublicKey(this.privateConstructorKey, bytes));
-  }
-  static async fromPrivate(bytes) {
-    const publicKey = await Elliptic3.publicKeyFromPrivateKey(toArrayBuffer(bytes));
-    return new PublicKey(this.privateConstructorKey, publicKey);
-  }
-  static isPublicKey(value) {
-    return value._isPublicKey;
-  }
-  get address() {
-    return this._address;
-  }
-  async verify(msg, signature) {
-    return await Elliptic3.verify(msg, signature, this.address.bytes);
-  }
-};
-__publicField(PublicKey, "privateConstructorKey", Date.now().toString());
-PublicKey = __decorateClass([
-  staticImplements2()
-], PublicKey);
-
-// src/Jwt/verifyJwt.ts
-function checkHeader(header, reasons) {
-  if (header.alg !== JwtAlg2.ES256K) reasons.push(`unsupported alg: ${header.alg}`);
-  if (header.typ !== JwtTyp2.JWT) reasons.push(`unsupported typ: ${header.typ}`);
-  if (typeof header.pub !== "string" || header.pub.length === 0) reasons.push("header.pub missing");
-  if (typeof header.kid !== "string" || header.kid.length === 0) reasons.push("header.kid missing");
-}
-function checkPayloadShape(payload, reasons) {
-  if (typeof payload.schema !== "string" || payload.schema.length === 0) reasons.push("payload.schema missing");
-  if (typeof payload.iss !== "string") reasons.push("payload.iss missing");
-  if (typeof payload.aud !== "string") reasons.push("payload.aud missing");
-  if (typeof payload.iat !== "number") reasons.push("payload.iat missing");
-  if (typeof payload.exp !== "number") reasons.push("payload.exp missing");
-}
-function checkClaims(payload, options, reasons) {
-  const now = options.now ?? Math.floor(Date.now() / 1e3);
-  if (payload.exp <= now) reasons.push(`expired: exp=${payload.exp} now=${now}`);
-  if (typeof payload.nbf === "number" && payload.nbf > now) reasons.push(`not yet valid: nbf=${payload.nbf} now=${now}`);
-  if (options.audience !== void 0 && payload.aud !== options.audience) {
-    reasons.push(`audience mismatch: expected ${options.audience}, got ${payload.aud}`);
-  }
-}
-async function checkSignature(header, signature, signingInputB64, reasons) {
-  let publicKey;
-  try {
-    const pubBytes = toUint8Array2(header.pub);
-    publicKey = await PublicKey.create(pubBytes.buffer.slice(pubBytes.byteOffset, pubBytes.byteOffset + pubBytes.byteLength));
-  } catch (error) {
-    reasons.push(`invalid public key: ${error.message}`);
-    return;
-  }
-  const derivedAddress = normalizeAddress(toHex2(publicKey.address.bytes, { prefix: false }));
-  const expectedAddress = normalizeAddress(header.kid);
-  if (derivedAddress !== expectedAddress) {
-    reasons.push(`public key does not derive to kid: derived=${derivedAddress} kid=${expectedAddress}`);
-  }
-  const encoder = new TextEncoder();
-  const signingInput = encoder.encode(signingInputB64);
-  const digest = sha256Bytes(signingInput);
-  const digestBuffer = digest.buffer.slice(digest.byteOffset, digest.byteOffset + digest.byteLength);
-  const sigBuffer = signature.buffer.slice(signature.byteOffset, signature.byteOffset + signature.byteLength);
-  const valid = await publicKey.verify(digestBuffer, sigBuffer);
-  if (!valid) reasons.push("signature verification failed");
-}
-async function verifyJwt(token, options = {}) {
-  const reasons = [];
-  const parts = decodeJwt(token);
-  const {
-    header,
-    payload,
-    signature,
-    headerB64,
-    payloadB64
-  } = parts;
-  checkHeader(header, reasons);
-  checkPayloadShape(payload, reasons);
-  if (reasons.length > 0) {
-    return {
-      ok: false,
-      reasons,
-      header,
-      payload
-    };
-  }
-  checkClaims(payload, options, reasons);
-  if (normalizeAddress(header.kid) !== normalizeAddress(payload.iss)) {
-    reasons.push("header.kid does not match payload.iss");
-  }
-  await checkSignature(header, signature, `${headerB64}.${payloadB64}`, reasons);
-  if (reasons.length > 0) {
-    return {
-      ok: false,
-      reasons,
-      header,
-      payload
-    };
-  }
-  return {
-    ok: true,
-    header,
-    payload
-  };
-}
-
-// src/Key/PrivateKey.ts
-import {
-  assertEx as assertEx2,
-  staticImplements as staticImplements3,
-  toArrayBuffer as toArrayBuffer2
-} from "@xylabs/sdk";
-import { Elliptic as Elliptic4 } from "../../elliptic/neutral/index.mjs";
-var PrivateKey = class extends EllipticKey {
-  _isPrivateKey = true;
-  _public;
-  constructor(privateConstructorKey, value, publicKey) {
-    assertEx2(PrivateKey.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
-    super(32, value);
-    this._public = publicKey;
-  }
-  static async create(value) {
-    return new PrivateKey(this.privateConstructorKey, toArrayBuffer2(value), await PublicKey.fromPrivate(value));
-  }
-  static isPrivateKey(value) {
-    return value._isPrivateKey;
-  }
-  get public() {
-    return this._public;
-  }
-  async sign(hash) {
-    return await Elliptic4.sign(hash, this.bytes);
-  }
-  async verify(msg, signature) {
-    return await Elliptic4.verify(msg, signature, this.public.address.bytes);
-  }
-};
-__publicField(PrivateKey, "privateConstructorKey", Date.now().toString());
-PrivateKey = __decorateClass([
-  staticImplements3()
-], PrivateKey);
-
-// src/Account.ts
-function getPrivateKeyFromMnemonic(mnemonic, path) {
-  const node = HDNodeWallet.fromMnemonic(mnemonic);
-  const wallet = isString(path) ? node.derivePath?.(path) : node;
-  return wallet.privateKey.padStart(64, "0").toLowerCase();
-}
-function getPrivateKeyFromPhrase(phrase, path) {
-  const node = HDNodeWallet.fromMnemonic(Mnemonic.fromPhrase(phrase));
-  const wallet = isString(path) ? node.derivePath?.(path) : node;
-  return wallet.privateKey.padStart(64, "0").toLowerCase();
-}
-var Account = class extends EllipticKey {
-  _privateKey;
-  _signingMutex = new Mutex();
-  _node = void 0;
-  _previousHash;
-  algorithm = "secp256k1";
-  constructor(key, privateKey, node) {
-    assertEx3(key === Account._protectedConstructorKey, () => "Do not call this protected constructor");
-    super(32, privateKey.bytes);
-    this._privateKey = privateKey;
-    this._node = node;
-  }
-  static async create(opts) {
-    let privateKeyToUse;
-    let node;
-    if (opts) {
-      if (isPhraseInitializationConfig(opts)) {
-        privateKeyToUse = toUint8Array3(getPrivateKeyFromPhrase(opts.phrase));
-      } else if (isPrivateKeyInitializationConfig(opts)) {
-        privateKeyToUse = toUint8Array3(opts.privateKey);
-      } else if (isMnemonicInitializationConfig(opts)) {
-        privateKeyToUse = toUint8Array3(getPrivateKeyFromMnemonic(Mnemonic.fromPhrase(opts.mnemonic), opts?.path));
-        node = isString(opts?.path) ? HDNodeWallet.fromPhrase(opts.mnemonic).derivePath?.(opts.path) : HDNodeWallet.fromPhrase(opts.mnemonic);
-      }
-    }
-    privateKeyToUse = privateKeyToUse ?? randomBytes(32);
-    const privateKey = await PrivateKey.create(privateKeyToUse.buffer);
-    const account = new Account(this._protectedConstructorKey, privateKey, node);
-    const loaded = await account.loadPreviousHash(opts?.previousHash);
-    return loaded.verifyUniqueAddress();
-  }
-  static decodeJwt(token) {
-    return decodeJwt(token);
-  }
-  static async fromPrivateKey(key) {
-    const privateKey = toUint8Array3(key, 32)?.buffer;
-    return await this.create({ privateKey });
-  }
-  static isAddress(address) {
-    return address.length === 40;
-  }
-  static async random() {
-    return await this.create();
-  }
-  static async verifyJwt(token, options) {
-    return await verifyJwt(token, options);
-  }
-  get address() {
-    return asAddress(this.public.address.hex, true);
-  }
-  get addressBytes() {
-    return this.public.address.bytes;
-  }
-  get previousHash() {
-    return this.previousHashBytes ? toHex3(this.previousHashBytes, { prefix: false }).toLowerCase() : void 0;
-  }
-  get previousHashBytes() {
-    return this._previousHash;
-  }
-  get private() {
-    return this._privateKey;
-  }
-  get public() {
-    return this.private.public;
-  }
-  async initialize() {
-    return await Promise.resolve(this);
-  }
-  async loadPreviousHash(previousHash) {
-    return await this._signingMutex.runExclusive(async () => {
-      if (isDefined2(previousHash)) {
-        this._previousHash = toUint8Array3(previousHash, 32).buffer;
-      } else {
-        const previousHashStoreValue = await Account.previousHashStore?.getItem(this.address);
-        if (isHash(previousHashStoreValue)) {
-          this._previousHash = toUint8Array3(previousHashStoreValue, 32).buffer;
-        }
-      }
-      return this;
-    });
-  }
-  async sign(hash, previousHash) {
-    await Elliptic5.initialize();
-    return await this._signingMutex.runExclusive(async () => {
-      if (Account.previousHashStore) {
-        const storedPreviousHash = await Account.previousHashStore.getItem(this.address);
-        this._previousHash = isHash(storedPreviousHash) ? toArrayBuffer3(storedPreviousHash, 32) : void 0;
-      }
-      const currentPreviousHash = this.previousHash;
-      const passedCurrentHash = previousHash === void 0 ? this.previousHash : toHex3(previousHash, { prefix: false });
-      assertEx3(
-        currentPreviousHash === passedCurrentHash,
-        () => `Used and current previous hashes do not match [${currentPreviousHash} !== ${passedCurrentHash}]`
-      );
-      const signature = await this.private.sign(hash);
-      const newPreviousHash = toUint8Array3(hash, 32).buffer;
-      this._previousHash = newPreviousHash;
-      if (Account.previousHashStore) {
-        await Account.previousHashStore.setItem(this.address, asHash(toHex3(newPreviousHash, { prefix: false }), true));
-      }
-      return [signature, currentPreviousHash];
-    });
-  }
-  async signJwt(options) {
-    return await createJwt(this, options);
-  }
-  async verify(msg, signature) {
-    await Elliptic5.initialize();
-    return await Elliptic5.verify(msg, signature, this.addressBytes);
-  }
-  verifyUniqueAddress() {
-    const address = this.address;
-    const currentAddressObject = Account._addressMap[address]?.deref();
-    if (currentAddressObject === void 0) {
-      Account._addressMap[address] = new WeakRef(this);
-    } else {
-      return currentAddressObject;
-    }
-    return this;
-  }
-};
-__publicField(Account, "previousHashStore");
-__publicField(Account, "uniqueName", globallyUnique("Account", Account, "xyo"));
-__publicField(Account, "_addressMap", {});
-__publicField(Account, "_protectedConstructorKey", /* @__PURE__ */ Symbol());
-Account = __decorateClass([
-  staticImplements4()
-], Account);
-
-// src/lib/walletPath/formatWalletPath.ts
-var formatWalletPath = (path) => {
-  return path.trimStart().trimEnd().split("/").filter((p) => !!p).join("/");
-};
-
-// src/lib/walletPath/combineWalletPaths.ts
-var combineWalletPaths = (path1, path2) => {
-  const parts1 = formatWalletPath(path1).split("/");
-  const parts2 = formatWalletPath(path2).split("/");
-  return [...parts1, ...parts2].join("/");
-};
-
-// src/lib/walletPath/isValidWalletPath.ts
-import { isString as isString2 } from "@xylabs/sdk";
-var pathSegmentRegex = /^\d+'?$/;
-var isValidAbsoluteWalletPath = (path) => {
-  if (!isString2(path)) return false;
-  if (!path.startsWith("m")) return false;
-  return path === "m" ? true : isValidRelativeWalletPath(path.slice(2));
-};
-var isValidRelativeWalletPath = (path) => {
-  if (!isString2(path)) return false;
-  if (path.length === 0 || path.startsWith("m")) return false;
-  const parts = path.split("/");
-  if (parts.some((p) => !p)) return false;
-  return parts.slice(1).every((p) => pathSegmentRegex.test(p));
-};
-export {
-  Account,
-  AddressValue,
-  EllipticKey,
-  PrivateKey,
-  PublicKey,
-  base64urlDecode,
-  base64urlDecodeJson,
-  base64urlEncode,
-  base64urlEncodeJson,
-  combineWalletPaths,
-  createJwt,
-  decodeJwt,
-  formatWalletPath,
-  isValidAbsoluteWalletPath,
-  isValidRelativeWalletPath,
-  normalizeAddress,
-  sha256Bytes,
-  stripHexPrefix,
-  verifyJwt
-};

package/dist/_pkg/account/neutral/lib/index.d.ts

@@ -1 +0,0 @@
-export * from './walletPath/index.ts';

package/dist/_pkg/account/neutral/lib/walletPath/combineWalletPaths.d.ts

@@ -1 +0,0 @@
-export declare const combineWalletPaths: (path1: string, path2: string) => string;

package/dist/_pkg/account/neutral/lib/walletPath/formatWalletPath.d.ts

@@ -1 +0,0 @@
-export declare const formatWalletPath: (path: string) => string;

package/dist/_pkg/account/neutral/lib/walletPath/index.d.ts

@@ -1,3 +0,0 @@
-export * from './combineWalletPaths.ts';
-export * from './formatWalletPath.ts';
-export * from './isValidWalletPath.ts';

package/dist/_pkg/account/neutral/lib/walletPath/isValidWalletPath.d.ts

@@ -1,2 +0,0 @@
-export declare const isValidAbsoluteWalletPath: (path?: string) => boolean;
-export declare const isValidRelativeWalletPath: (path?: string) => boolean;

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

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

package/dist/_pkg/account-model/neutral/Account.d.ts

@@ -1,45 +0,0 @@
-import type { Hash } from '@xylabs/sdk';
-import type { XyoAddress } from '../../address/neutral/index.ts';
-import type { PrivateKeyInstance, PublicKeyInstance } from '../../key-model/neutral/index.ts';
-import type { PreviousHashStore } from '../../previous-hash-store-model/neutral/index.ts';
-import type { AccountAlgorithm } from './Algorithm.ts';
-import type { SignJwtOptions, SignJwtResult } from './Jwt/types.ts';
-export declare const ethMessagePrefix = "\u0019Ethereum Signed Message:\n";
-export interface PhraseInitializationConfig {
-    phrase: string;
-}
-export interface PrivateKeyInitializationConfig {
-    privateKey: ArrayBufferLike;
-}
-export interface MnemonicInitializationConfig {
-    mnemonic: string;
-    path?: string;
-}
-export interface AccountOptions {
-    previousHash?: ArrayBufferLike;
-}
-export type InitializationConfig = PhraseInitializationConfig | PrivateKeyInitializationConfig | MnemonicInitializationConfig;
-export type AccountConfig = InitializationConfig & AccountOptions;
-export declare const isPhraseInitializationConfig: (value: unknown) => value is PhraseInitializationConfig;
-export declare const isPrivateKeyInitializationConfig: (value: unknown) => value is PrivateKeyInitializationConfig;
-export declare const isMnemonicInitializationConfig: (value: unknown) => value is MnemonicInitializationConfig;
-export declare const isInitializationConfig: (value: unknown) => value is InitializationConfig;
-export interface AccountInstance {
-    readonly address: XyoAddress;
-    readonly addressBytes: ArrayBufferLike;
-    readonly algorithm: AccountAlgorithm;
-    previousHash: Hash | undefined;
-    previousHashBytes: ArrayBufferLike | undefined;
-    readonly private?: PrivateKeyInstance;
-    readonly public?: PublicKeyInstance;
-    sign: (hash: ArrayBufferLike, previousHash?: ArrayBufferLike) => Promise<[ArrayBufferLike, Hash?]>;
-    signJwt: (options: SignJwtOptions) => Promise<SignJwtResult>;
-    verify: (msg: ArrayBufferLike, signature: ArrayBufferLike) => Promise<boolean>;
-}
-export declare const isAccountInstance: (account: unknown) => account is AccountInstance;
-export interface AccountStatic<T extends AccountInstance = AccountInstance, C extends AccountConfig = AccountConfig> {
-    previousHashStore?: PreviousHashStore;
-    create(options?: C): Promise<T>;
-    fromPrivateKey(key: ArrayBufferLike | bigint | string): Promise<AccountInstance>;
-    random(): Promise<AccountInstance>;
-}

package/dist/_pkg/account-model/neutral/Algorithm.d.ts

@@ -1,4 +0,0 @@
-export type AccountAlgorithm = 'secp256k1' | 'ml-dsa-65';
-export declare const AccountAlgorithmHrp: Partial<Record<AccountAlgorithm, string>>;
-export declare function hrpForAlgorithm(algorithm: AccountAlgorithm): string | undefined;
-export declare function algorithmFromAddress(address: string): AccountAlgorithm;

package/dist/_pkg/account-model/neutral/Jwt/constants.d.ts

@@ -1,13 +0,0 @@
-import { Enum } from '@xylabs/sdk';
-export declare const JwtAlg: Enum<{
-    ES256K: "ES256K";
-}>;
-export type JwtAlg = Enum<typeof JwtAlg>;
-export declare const JwtTyp: Enum<{
-    JWT: "JWT";
-}>;
-export type JwtTyp = Enum<typeof JwtTyp>;
-export declare const JwtSchema: Enum<{
-    Signin: "network.xyo.auth.signin";
-}>;
-export type JwtSchema = Enum<typeof JwtSchema>;

package/dist/_pkg/account-model/neutral/Jwt/index.d.ts

@@ -1,2 +0,0 @@
-export * from './constants.ts';
-export * from './types.ts';

package/dist/_pkg/account-model/neutral/Jwt/types.d.ts

@@ -1,55 +0,0 @@
-export interface JwtHeader {
-    alg: string;
-    kid: string;
-    pub: string;
-    typ: string;
-}
-export interface JwtClaims {
-    aud: string;
-    exp: number;
-    iat: number;
-    iss: string;
-    nbf?: number;
-    nonce?: string;
-}
-export interface JwtPayload extends JwtClaims {
-    [key: string]: unknown;
-    schema: string;
-}
-export interface JwtParts {
-    header: JwtHeader;
-    headerB64: string;
-    payload: JwtPayload;
-    payloadB64: string;
-    signature: Uint8Array;
-    signatureB64: string;
-}
-export interface SignJwtOptions {
-    audience: string;
-    claims?: Record<string, unknown>;
-    exp?: number;
-    now?: number;
-    schema?: string;
-    ttl?: number;
-}
-export interface SignJwtResult {
-    header: JwtHeader;
-    payload: JwtPayload;
-    token: string;
-}
-export interface VerifyJwtOptions {
-    audience?: string;
-    now?: number;
-}
-export interface VerifyJwtSuccess {
-    header: JwtHeader;
-    ok: true;
-    payload: JwtPayload;
-}
-export interface VerifyJwtFailure {
-    header?: JwtHeader;
-    ok: false;
-    payload?: JwtPayload;
-    reasons: string[];
-}
-export type VerifyJwtResult = VerifyJwtSuccess | VerifyJwtFailure;