@aboutcircles/sdk 0.1.0

package/dist/errors.d.ts

@@ -0,0 +1,64 @@
+/**
+ * SDK Package Error Types
+ */
+import { CirclesError } from '@aboutcircles/sdk-utils';
+/**
+ * SDK-specific error sources
+ */
+export type SdkErrorSource = 'SDK' | 'SDK_INITIALIZATION' | 'SDK_CONFIG' | 'SDK_OPERATION';
+/**
+ * SDK-related errors
+ */
+export declare class SdkError extends CirclesError<SdkErrorSource> {
+    constructor(message: string, options?: {
+        code?: string | number;
+        source?: SdkErrorSource;
+        cause?: unknown;
+        context?: Record<string, any>;
+    });
+    /**
+     * Create error for uninitialized components
+     */
+    static notInitialized(component: string): SdkError;
+    /**
+     * Create error for unsupported operations
+     */
+    static unsupportedOperation(operation: string, reason?: string): SdkError;
+    /**
+     * Create error for configuration issues
+     */
+    static configError(message: string, context?: Record<string, any>): SdkError;
+    /**
+     * Create error for failed operations
+     */
+    static operationFailed(operation: string, reason: string, cause?: unknown): SdkError;
+    /**
+     * Create error for missing contract runner
+     */
+    static missingContractRunner(operation?: string): SdkError;
+    /**
+     * Create error for avatar not found
+     */
+    static avatarNotFound(address: string): SdkError;
+    /**
+     * Create error for invalid profile
+     */
+    static invalidProfile(reason: string, context?: Record<string, any>): SdkError;
+    /**
+     * Create error for profile operation failures
+     */
+    static profileOperationFailed(operation: string, reason: string, cause?: unknown): SdkError;
+    /**
+     * Create error for insufficient balance
+     */
+    static insufficientBalance(required: string, available: string, token?: string): SdkError;
+    /**
+     * Create error for transaction extraction failures
+     */
+    static transactionDataExtractionFailed(dataType: string, reason?: string): SdkError;
+    /**
+     * Create error for registration failures
+     */
+    static registrationFailed(avatarType: string, reason: string, cause?: unknown): SdkError;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD;;GAEG;AACH,MAAM,MAAM,cAAc,GACtB,KAAK,GACL,oBAAoB,GACpB,YAAY,GACZ,eAAe,CAAC;AAEpB;;GAEG;AACH,qBAAa,QAAS,SAAQ,YAAY,CAAC,cAAc,CAAC;gBAEtD,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QACvB,MAAM,CAAC,EAAE,cAAc,CAAC;QACxB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KAC/B;IAKH;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ;IAQlD;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ;IAWzE;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,QAAQ;IAQ5E;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,QAAQ;IASpF;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ;IAa1D;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ;IAQhD;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,QAAQ;IAQ9E;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,QAAQ;IAS3F;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ;IAazF;;OAEG;IACH,MAAM,CAAC,+BAA+B,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ;IAanF;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,QAAQ;CAQzF"}

package/dist/errors.js

@@ -0,0 +1,131 @@
+/**
+ * SDK Package Error Types
+ */
+import { CirclesError } from '@aboutcircles/sdk-utils';
+/**
+ * SDK-related errors
+ */
+export class SdkError extends CirclesError {
+    constructor(message, options) {
+        super('SdkError', message, { ...options, source: options?.source ?? 'SDK' });
+    }
+    /**
+     * Create error for uninitialized components
+     */
+    static notInitialized(component) {
+        return new SdkError(`${component} is not initialized`, {
+            code: 'SDK_NOT_INITIALIZED',
+            source: 'SDK_INITIALIZATION',
+            context: { component },
+        });
+    }
+    /**
+     * Create error for unsupported operations
+     */
+    static unsupportedOperation(operation, reason) {
+        return new SdkError(reason ? `Operation '${operation}' is not supported: ${reason}` : `Operation '${operation}' is not supported`, {
+            code: 'SDK_UNSUPPORTED_OPERATION',
+            source: 'SDK_OPERATION',
+            context: { operation, reason },
+        });
+    }
+    /**
+     * Create error for configuration issues
+     */
+    static configError(message, context) {
+        return new SdkError(message, {
+            code: 'SDK_CONFIG_ERROR',
+            source: 'SDK_CONFIG',
+            context,
+        });
+    }
+    /**
+     * Create error for failed operations
+     */
+    static operationFailed(operation, reason, cause) {
+        return new SdkError(`Operation '${operation}' failed: ${reason}`, {
+            code: 'SDK_OPERATION_FAILED',
+            source: 'SDK_OPERATION',
+            cause,
+            context: { operation, reason },
+        });
+    }
+    /**
+     * Create error for missing contract runner
+     */
+    static missingContractRunner(operation) {
+        return new SdkError(operation
+            ? `${operation} requires a contract runner. Initialize SDK with a ContractRunner.`
+            : 'Operation requires a contract runner. Initialize SDK with a ContractRunner.', {
+            code: 'SDK_MISSING_CONTRACT_RUNNER',
+            source: 'SDK_INITIALIZATION',
+            context: { operation },
+        });
+    }
+    /**
+     * Create error for avatar not found
+     */
+    static avatarNotFound(address) {
+        return new SdkError(`Avatar not found at address: ${address}`, {
+            code: 'SDK_AVATAR_NOT_FOUND',
+            source: 'SDK_OPERATION',
+            context: { address },
+        });
+    }
+    /**
+     * Create error for invalid profile
+     */
+    static invalidProfile(reason, context) {
+        return new SdkError(`Invalid profile: ${reason}`, {
+            code: 'SDK_INVALID_PROFILE',
+            source: 'SDK_OPERATION',
+            context,
+        });
+    }
+    /**
+     * Create error for profile operation failures
+     */
+    static profileOperationFailed(operation, reason, cause) {
+        return new SdkError(`Profile ${operation} failed: ${reason}`, {
+            code: 'SDK_PROFILE_OPERATION_FAILED',
+            source: 'SDK_OPERATION',
+            cause,
+            context: { operation, reason },
+        });
+    }
+    /**
+     * Create error for insufficient balance
+     */
+    static insufficientBalance(required, available, token) {
+        return new SdkError(token
+            ? `Insufficient ${token} balance. Required: ${required}, Available: ${available}`
+            : `Insufficient balance. Required: ${required}, Available: ${available}`, {
+            code: 'SDK_INSUFFICIENT_BALANCE',
+            source: 'SDK_OPERATION',
+            context: { required, available, token },
+        });
+    }
+    /**
+     * Create error for transaction extraction failures
+     */
+    static transactionDataExtractionFailed(dataType, reason) {
+        return new SdkError(reason
+            ? `Failed to extract ${dataType} from transaction: ${reason}`
+            : `Failed to extract ${dataType} from transaction`, {
+            code: 'SDK_TX_DATA_EXTRACTION_FAILED',
+            source: 'SDK_OPERATION',
+            context: { dataType, reason },
+        });
+    }
+    /**
+     * Create error for registration failures
+     */
+    static registrationFailed(avatarType, reason, cause) {
+        return new SdkError(`Failed to register ${avatarType}: ${reason}`, {
+            code: 'SDK_REGISTRATION_FAILED',
+            source: 'SDK_OPERATION',
+            cause,
+            context: { avatarType, reason },
+        });
+    }
+}

package/dist/index-3hqyeswk.js

@@ -0,0 +1,25 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export { __toESM, __require };

package/dist/index-pps0tkk3.js

@@ -0,0 +1,356 @@
+// ../../node_modules/@noble/hashes/esm/crypto.js
+var crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : undefined;
+
+// ../../node_modules/@noble/hashes/esm/utils.js
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function ahash(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new Error("Hash should be wrapped by utils.createHasher");
+  anumber(h.outputLen);
+  anumber(h.blockLen);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0;i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap32(arr) {
+  for (let i = 0;i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+  return arr;
+}
+var swap32IfBE = isLE ? (u) => u : byteSwap32;
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+function concatBytes(...arrays) {
+  let sum = 0;
+  for (let i = 0;i < arrays.length; i++) {
+    const a = arrays[i];
+    abytes(a);
+    sum += a.length;
+  }
+  const res = new Uint8Array(sum);
+  for (let i = 0, pad = 0;i < arrays.length; i++) {
+    const a = arrays[i];
+    res.set(a, pad);
+    pad += a.length;
+  }
+  return res;
+}
+class Hash {
+}
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+function randomBytes(bytesLength = 32) {
+  if (crypto && typeof crypto.getRandomValues === "function") {
+    return crypto.getRandomValues(new Uint8Array(bytesLength));
+  }
+  if (crypto && typeof crypto.randomBytes === "function") {
+    return Uint8Array.from(crypto.randomBytes(bytesLength));
+  }
+  throw new Error("crypto.getRandomValues must be defined");
+}
+
+// ../../node_modules/@noble/curves/esm/abstract/utils.js
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var _0n = /* @__PURE__ */ BigInt(0);
+var _1n = /* @__PURE__ */ BigInt(1);
+function isBytes2(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes2(item) {
+  if (!isBytes2(item))
+    throw new Error("Uint8Array expected");
+}
+function abool(title, value) {
+  if (typeof value !== "boolean")
+    throw new Error(title + " boolean expected, got " + value);
+}
+function numberToHexUnpadded(num) {
+  const hex = num.toString(16);
+  return hex.length & 1 ? "0" + hex : hex;
+}
+function hexToNumber(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  return hex === "" ? _0n : BigInt("0x" + hex);
+}
+var hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  abytes2(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0;i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function asciiToBase16(ch) {
+  if (ch >= asciis._0 && ch <= asciis._9)
+    return ch - asciis._0;
+  if (ch >= asciis.A && ch <= asciis.F)
+    return ch - (asciis.A - 10);
+  if (ch >= asciis.a && ch <= asciis.f)
+    return ch - (asciis.a - 10);
+  return;
+}
+function hexToBytes(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  if (hasHexBuiltin)
+    return Uint8Array.fromHex(hex);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + hl);
+  const array = new Uint8Array(al);
+  for (let ai = 0, hi = 0;ai < al; ai++, hi += 2) {
+    const n1 = asciiToBase16(hex.charCodeAt(hi));
+    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+    if (n1 === undefined || n2 === undefined) {
+      const char = hex[hi] + hex[hi + 1];
+      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+    }
+    array[ai] = n1 * 16 + n2;
+  }
+  return array;
+}
+function bytesToNumberBE(bytes) {
+  return hexToNumber(bytesToHex(bytes));
+}
+function bytesToNumberLE(bytes) {
+  abytes2(bytes);
+  return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
+}
+function numberToBytesBE(n, len) {
+  return hexToBytes(n.toString(16).padStart(len * 2, "0"));
+}
+function numberToBytesLE(n, len) {
+  return numberToBytesBE(n, len).reverse();
+}
+function ensureBytes(title, hex, expectedLength) {
+  let res;
+  if (typeof hex === "string") {
+    try {
+      res = hexToBytes(hex);
+    } catch (e) {
+      throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
+    }
+  } else if (isBytes2(hex)) {
+    res = Uint8Array.from(hex);
+  } else {
+    throw new Error(title + " must be hex string or Uint8Array");
+  }
+  const len = res.length;
+  if (typeof expectedLength === "number" && len !== expectedLength)
+    throw new Error(title + " of length " + expectedLength + " expected, got " + len);
+  return res;
+}
+function concatBytes2(...arrays) {
+  let sum = 0;
+  for (let i = 0;i < arrays.length; i++) {
+    const a = arrays[i];
+    abytes2(a);
+    sum += a.length;
+  }
+  const res = new Uint8Array(sum);
+  for (let i = 0, pad = 0;i < arrays.length; i++) {
+    const a = arrays[i];
+    res.set(a, pad);
+    pad += a.length;
+  }
+  return res;
+}
+function utf8ToBytes2(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+var isPosBig = (n) => typeof n === "bigint" && _0n <= n;
+function inRange(n, min, max) {
+  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
+}
+function aInRange(title, n, min, max) {
+  if (!inRange(n, min, max))
+    throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
+}
+function bitLen(n) {
+  let len;
+  for (len = 0;n > _0n; n >>= _1n, len += 1)
+    ;
+  return len;
+}
+var bitMask = (n) => (_1n << BigInt(n)) - _1n;
+var u8n = (len) => new Uint8Array(len);
+var u8fr = (arr) => Uint8Array.from(arr);
+function createHmacDrbg(hashLen, qByteLen, hmacFn) {
+  if (typeof hashLen !== "number" || hashLen < 2)
+    throw new Error("hashLen must be a number");
+  if (typeof qByteLen !== "number" || qByteLen < 2)
+    throw new Error("qByteLen must be a number");
+  if (typeof hmacFn !== "function")
+    throw new Error("hmacFn must be a function");
+  let v = u8n(hashLen);
+  let k = u8n(hashLen);
+  let i = 0;
+  const reset = () => {
+    v.fill(1);
+    k.fill(0);
+    i = 0;
+  };
+  const h = (...b) => hmacFn(k, v, ...b);
+  const reseed = (seed = u8n(0)) => {
+    k = h(u8fr([0]), seed);
+    v = h();
+    if (seed.length === 0)
+      return;
+    k = h(u8fr([1]), seed);
+    v = h();
+  };
+  const gen = () => {
+    if (i++ >= 1000)
+      throw new Error("drbg: tried 1000 values");
+    let len = 0;
+    const out = [];
+    while (len < qByteLen) {
+      v = h();
+      const sl = v.slice();
+      out.push(sl);
+      len += v.length;
+    }
+    return concatBytes2(...out);
+  };
+  const genUntil = (seed, pred) => {
+    reset();
+    reseed(seed);
+    let res = undefined;
+    while (!(res = pred(gen())))
+      reseed();
+    reset();
+    return res;
+  };
+  return genUntil;
+}
+var validatorFns = {
+  bigint: (val) => typeof val === "bigint",
+  function: (val) => typeof val === "function",
+  boolean: (val) => typeof val === "boolean",
+  string: (val) => typeof val === "string",
+  stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
+  isSafeInteger: (val) => Number.isSafeInteger(val),
+  array: (val) => Array.isArray(val),
+  field: (val, object) => object.Fp.isValid(val),
+  hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
+};
+function validateObject(object, validators, optValidators = {}) {
+  const checkField = (fieldName, type, isOptional) => {
+    const checkVal = validatorFns[type];
+    if (typeof checkVal !== "function")
+      throw new Error("invalid validator function");
+    const val = object[fieldName];
+    if (isOptional && val === undefined)
+      return;
+    if (!checkVal(val, object)) {
+      throw new Error("param " + String(fieldName) + " is invalid. Expected " + type + ", got " + val);
+    }
+  };
+  for (const [fieldName, type] of Object.entries(validators))
+    checkField(fieldName, type, false);
+  for (const [fieldName, type] of Object.entries(optValidators))
+    checkField(fieldName, type, true);
+  return object;
+}
+function memoized(fn) {
+  const map = new WeakMap;
+  return (arg, ...args) => {
+    const val = map.get(arg);
+    if (val !== undefined)
+      return val;
+    const computed = fn(arg, ...args);
+    map.set(arg, computed);
+    return computed;
+  };
+}
+
+// ../../node_modules/@noble/hashes/esm/_u64.js
+var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+var _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0;i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+
+export { split, rotlSH, rotlSL, rotlBH, rotlBL, anumber, abytes, ahash, aexists, aoutput, u32, clean, createView, rotr, swap32IfBE, toBytes, concatBytes, Hash, createHasher, randomBytes, isBytes2 as isBytes, abytes2 as abytes1, abool, numberToHexUnpadded, bytesToHex, hexToBytes, bytesToNumberBE, bytesToNumberLE, numberToBytesBE, numberToBytesLE, ensureBytes, concatBytes2 as concatBytes1, utf8ToBytes2 as utf8ToBytes, inRange, aInRange, bitLen, bitMask, createHmacDrbg, validateObject, memoized };

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { Sdk } from './Sdk';
+export { HumanAvatar, OrganisationAvatar, BaseGroupAvatar } from './avatars';
+export type { PathfindingOptions } from './avatars';
+export type { TransactionReceipt } from 'viem';
+import type { HumanAvatar, BaseGroupAvatar, OrganisationAvatar } from './avatars';
+export type Avatar = HumanAvatar | BaseGroupAvatar | OrganisationAvatar;
+export { SdkError } from './errors';
+export type { SdkErrorSource } from './errors';
+export type { AggregatedTrustRelation, TrustRelationType, CirclesEvent, CirclesEventType, Observable, TransactionHistoryRow, SearchResultProfile, GroupTokenHolderRow, } from '@aboutcircles/sdk-rpc';
+export type { AvatarRow, TokenBalanceRow, TrustRelationRow, CirclesQuery, GroupType, ContractRunner } from '@aboutcircles/sdk-types';
+export type { CirclesData } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAG5B,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC7E,YAAY,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACpD,YAAY,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAC;AAG/C,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAClF,MAAM,MAAM,MAAM,GAAG,WAAW,GAAG,eAAe,GAAG,kBAAkB,CAAC;AAGxE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAG/C,YAAY,EACV,uBAAuB,EACvB,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAGrI,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}