@arkiv-network/sdk 0.8.1-dev.1 → 0.9.0-next.2

package/src/utils/arkivTransactions.ts

@@ -13,8 +13,6 @@ import type { CreateEntityParameters } from "../actions/wallet/createEntity"
 import type { DeleteEntityParameters } from "../actions/wallet/deleteEntity"
 import type { ExtendEntityParameters } from "../actions/wallet/extendEntity"
 import type { PatchEntityParameters } from "../actions/wallet/patchEntity"
-// Internal seam: the ABI encoders are not part of the package's public surface.
-import { encodeAttributes, encodeMutations } from "../attr/attributes"
 import type { ArkivClient } from "../clients/baseClient"
 import type { WalletArkivClient } from "../clients/createWalletClient"
 import { ARKIV_ADDRESS } from "../consts"
@@ -31,7 +29,9 @@ import {
   patchOperation,
   transferOwnershipOperation,
 } from "../entity/operations"
-import { EmptyPatchError, EntityMutationError, InvalidContentTypeError } from "../errors"
+import { EmptyPatchError, EntityMutationError } from "../errors"
+// Internal seam: the ABI encoders are not part of the package's public surface.
+import { encodeCreate, encodePatch } from "../schema/attributes"
 import type { TxParams } from "../types"
 
 import { getLogger } from "./logger"
@@ -39,16 +39,7 @@ import { describeEntityRevert } from "./revert"
 
 const logger = getLogger("utils:arkiv-transactions")
 
-// RFC 2045 token chars, lowercase only. Rejects uppercase to prevent text/plain vs Text/Plain ambiguity.
-const MIME_REGEX = /^[a-z][a-z0-9!#$&\-^_]*\/[a-z0-9][a-z0-9!#$&\-^_.+]*$/
-
-function validateContentType(contentType: string): void {
-  if (!MIME_REGEX.test(contentType)) {
-    throw new InvalidContentTypeError(contentType)
-  }
-}
-
-export const ENTITY_ERRORS_ABI = parseAbi([
+const ENTITY_ERRORS_ABI = parseAbi([
   // Batch and operation framing.
   "error EmptyBatch()",
   "error InvalidOpType(uint8 operation)",
@@ -70,8 +61,8 @@ export const ENTITY_ERRORS_ABI = parseAbi([
   "error NotOwner(bytes32 entityKey, address caller, address owner)",
   "error ReadOnlyEntity(bytes32 entityKey)",
   "error ReservedCreationFlags(uint8 creationFlags)",
-  // Expiry. The engine bounds an expiry only by the width of the field and by liveness — there is
-  // no MAX_EXPIRES_AT or MAX_LIFETIME, so there is no error for exceeding one.
+  // Expiry. The engine bounds an expiry only by the uint64 width of the field — the SDK's
+  // MAX_EXPIRES_AT — and by liveness. There is no separate cap on lifetime, so no error for one.
   "error ExpiryDeadOnArrival(uint64 target, uint64 currentBlock)",
   "error ExpiryNotExtended(bytes32 entityKey, uint64 newExpiresAt, uint64 currentExpiresAt)",
   // Ownership transfer.
@@ -94,11 +85,11 @@ export type SendArkivTransactionResult = {
 export async function sendArkivTransaction(
   client: ArkivClient,
   ops: {
-    creates?: CreateEntityParameters[]
-    patches?: PatchEntityParameters[]
-    deletes?: DeleteEntityParameters[]
-    extensions?: ExtendEntityParameters[]
-    ownershipChanges?: ChangeOwnershipParameters[]
+    creates?: readonly CreateEntityParameters[] | undefined
+    patches?: readonly PatchEntityParameters[] | undefined
+    deletes?: readonly DeleteEntityParameters[] | undefined
+    extensions?: readonly ExtendEntityParameters[] | undefined
+    ownershipChanges?: readonly ChangeOwnershipParameters[] | undefined
   },
   txParams?: TxParams,
 ): Promise<SendArkivTransactionResult> {
@@ -108,6 +99,21 @@ export async function sendArkivTransaction(
 
   const { creates, patches, deletes, extensions, ownershipChanges } = ops
 
+  // Every write is checked against its schema before the block read, so one that does not fit
+  // fails without touching the network — and a network failure cannot mask it.
+  const encodedCreates = (creates ?? []).map((item) => ({
+    item,
+    attributes: encodeCreate(item.schema, item.values),
+  }))
+
+  const patchOps = (patches ?? []).map((item) => {
+    const mutations = encodePatch(item.schema, item)
+    if (mutations.length === 0) {
+      throw new EmptyPatchError(item.entityKey)
+    }
+    return patchOperation({ entityKey: item.entityKey, mutations })
+  })
+
   // The block height, to resolve any relative expiry — which both creates and extensions carry.
   // Skipped entirely for a batch with neither.
   const currentBlock =
@@ -115,37 +121,23 @@ export async function sendArkivTransaction(
 
   const expiryContext = { currentBlock }
 
-  const createOps = (creates ?? []).map((item) => {
-    validateContentType(item.contentType)
-
+  const createOps = encodedCreates.map(({ item, attributes }) => {
     const salt = item.salt === undefined ? randomSalt() : resolveSalt(item.salt)
-    const expiry = resolveExpiry(item.expires, expiryContext)
+    const expiry = resolveExpiry(item.expiration, expiryContext)
 
     return createOperation({
       salt,
       expiry,
       creationFlags: encodeCreationFlags(item.flags),
-      attributes: encodeAttributes(item.attributes, {
-        payload: item.payload,
-        contentType: item.contentType,
-      }),
+      attributes,
     })
   })
 
-  const patchOps = (patches ?? []).map((item) => {
-    if (item.contentType !== undefined) validateContentType(item.contentType)
-    const mutations = encodeMutations(item)
-    if (mutations.length === 0) {
-      throw new EmptyPatchError(item.entityKey)
-    }
-    return patchOperation({ entityKey: item.entityKey, mutations })
-  })
-
   // An extension resolves its expiry exactly as a create does — the engine applies the same
   // `max(expiresAt, currentBlock + minLifetime)` to both — so the same bounds are checked here
   // rather than left to a revert.
   const extendOps = (extensions ?? []).map((item) => {
-    const expiry = resolveExpiry(item.expires, expiryContext)
+    const expiry = resolveExpiry(item.expiration, expiryContext)
     return extendExpiryOperation({ entityKey: item.entityKey, expiry })
   })
 

package/src/utils/entities.ts

@@ -1,12 +1,12 @@
-import { checksumAddress, type Hex, hexToBytes } from "viem"
-import type { AttributeSchema, Attributes } from "../attr"
-// Internal seam: the JSON-RPC decoder is not part of the package's public surface.
-import { asTypeTag, decodeRpcValue } from "../attr/codec"
+import { checksumAddress, type Hex } from "viem"
 import {
   decodeCreationFlags,
   encodeCreationFlags,
   type ResolvedCreationFlags,
 } from "../entity/flags"
+import type { AttributeSchema, Attributes } from "../schema"
+// Internal seam: the JSON-RPC decoder is not part of the package's public surface.
+import { asTypeTag, decodeRpcValue } from "../schema/codec"
 import { Entity, type EntityFields } from "../types/entity"
 import type { RpcEntity } from "../types/rpcSchema"
 import { getLogger } from "./logger"
@@ -29,9 +29,12 @@ function decodeAttributes(rpcAttributes: NonNullable<RpcEntity["attributes"]>):
 
 /** The same, for the values-free `attributeSchema` projection. */
 function decodeSchema(entries: NonNullable<RpcEntity["attributeSchema"]>): AttributeSchema {
-  const schema: Record<string, ReturnType<typeof asTypeTag>> = {}
-  for (const { name, type } of entries) {
-    schema[name] = asTypeTag(type)
+  const schema: Record<string, AttributeSchema[string]> = {}
+  for (const { name, type, indexed } of entries) {
+    schema[name] = {
+      type: asTypeTag(type),
+      indexed: typeof indexed === "boolean" ? indexed : undefined,
+    }
   }
   return schema
 }
@@ -53,8 +56,6 @@ export function entityFromRpcResult(rpcEntity: RpcEntity): Entity {
     updatedAt: toBlock(rpcEntity.updatedAt),
     expiresAt: toBlock(rpcEntity.expiresAt),
     creationFlags: decodeFlags(rpcEntity.creationFlags),
-    contentType: rpcEntity.contentType,
-    payload: rpcEntity.payload !== undefined ? hexToBytes(rpcEntity.payload) : undefined,
     attributeSchema:
       rpcEntity.attributeSchema !== undefined ? decodeSchema(rpcEntity.attributeSchema) : undefined,
     attributes:

package/src/utils/expirationTime.ts

@@ -23,7 +23,7 @@ function deadlineOf(expiresAt: bigint | Date, options?: DeadlineOptions): Expiry
 }
 
 /**
- * Builds the `expires` of a create or an extension.
+ * Builds the `expiration` of a create or an extension.
  *
  * Every helper returns the `{ minLifetime, expiresAt }` pair the ABI carries, so what you write is
  * what goes on the wire. The `from*` helpers fill `minLifetime` and leave `expiresAt` at `0n`;
@@ -34,14 +34,14 @@ function deadlineOf(expiresAt: bigint | Date, options?: DeadlineOptions): Expiry
  * object.
  *
  * @example The 90% case: a duration, and nothing else to think about.
- * await client.createEntity({ payload, contentType, expires: ExpirationTime.fromDays(30) })
+ * await client.createEntity(Posts, values, { expiration: ExpirationTime.fromDays(30) })
  *
  * @example An exact block, or a wall-clock date.
- * expires: ExpirationTime.atBlock(1_200_000n)
- * expires: ExpirationTime.atDate(new Date("2027-01-01"))
+ * expiration: ExpirationTime.atBlock(1_200_000n)
+ * expiration: ExpirationTime.atDate(new Date("2027-01-01"))
  *
  * @example A deadline that still guarantees a minimum life.
- * expires: ExpirationTime.atBlock(1_200_000n, { atLeast: ExpirationTime.fromDays(1) })
+ * expiration: ExpirationTime.atBlock(1_200_000n, { atLeast: ExpirationTime.fromDays(1) })
  */
 export const ExpirationTime = {
   /**

package/src/utils/index.ts

@@ -1,3 +1,2 @@
 export type { Expiry, Lifetime } from "../entity/expiry"
 export * from "./expirationTime"
-export * from "./payload"

package/src/utils/logger.test.ts

@@ -0,0 +1,45 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test"
+import { getLogger } from "./logger"
+
+describe("getLogger", () => {
+  const originalDebug = process.env.DEBUG
+  let log: ReturnType<typeof spyOn<Console, "log">>
+
+  beforeEach(() => {
+    log = spyOn(console, "log").mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    log.mockRestore()
+    if (originalDebug === undefined) delete process.env.DEBUG
+    else process.env.DEBUG = originalDebug
+  })
+
+  /** Which of `scopes` log anything under `debug`. */
+  function enabledScopes(debug: string, scopes: string[]): string[] {
+    process.env.DEBUG = debug
+    return scopes.filter((scope) => {
+      log.mockClear()
+      getLogger(scope)("hello")
+      return log.mock.calls.length > 0
+    })
+  }
+
+  test("logs only the namespaces a pattern names", () => {
+    expect(enabledScopes("arkiv:a", ["a", "b"])).toEqual(["a"])
+  })
+
+  test("a wildcard enables every namespace under its prefix", () => {
+    expect(enabledScopes("arkiv:*", ["a", "b"])).toEqual(["a", "b"])
+    expect(enabledScopes("arkiv:a:*", ["a:x", "a:y", "b:x"])).toEqual(["a:x", "a:y"])
+  })
+
+  test("a -pattern excludes what it matches and leaves the rest enabled", () => {
+    expect(enabledScopes("arkiv:*,-arkiv:a", ["a", "b", "c"])).toEqual(["b", "c"])
+    expect(enabledScopes("arkiv:* -arkiv:a:*", ["a:x", "a:y", "b:x"])).toEqual(["b:x"])
+  })
+
+  test("an exclusion alone enables nothing", () => {
+    expect(enabledScopes("-arkiv:a", ["a", "b"])).toEqual([])
+  })
+})

package/src/utils/logger.ts

@@ -23,7 +23,8 @@ function getDebugEnv(): string {
   return ""
 }
 
-// Parse debug patterns and check if a namespace matches
+// Check if a namespace matches a single positive pattern. Exclusions ("-pattern") are handled by
+// isEnabled, which strips the "-" and calls this with the rest.
 function matchesPattern(namespace: string, pattern: string): boolean {
   // Exact match
   if (pattern === namespace) return true
@@ -34,12 +35,6 @@ function matchesPattern(namespace: string, pattern: string): boolean {
     return namespace.startsWith(prefix)
   }
 
-  // Negative match: "-arkiv:query" excludes "arkiv:query"
-  if (pattern.startsWith("-")) {
-    const excludePattern = pattern.slice(1)
-    return !matchesPattern(namespace, excludePattern)
-  }
-
   return false
 }
 
@@ -58,8 +53,8 @@ function isEnabled(namespace: string): boolean {
   let enabled = false
   for (const pattern of patterns) {
     if (pattern.startsWith("-")) {
-      // Exclude pattern - if it matches, disable
-      if (matchesPattern(namespace, pattern)) {
+      // Exclude pattern: "-arkiv:query" disables "arkiv:query" whatever else enables it
+      if (matchesPattern(namespace, pattern.slice(1))) {
         return false
       }
     } else if (matchesPattern(namespace, pattern)) {
@@ -70,10 +65,6 @@ function isEnabled(namespace: string): boolean {
   return enabled
 }
 
-// Store enabled namespaces (for programmatic enable/disable)
-const enabledNamespaces: Set<string> = new Set()
-const disabledNamespaces: Set<string> = new Set()
-
 // Color palette for namespace coloring (distinct, readable colors)
 const COLOR_PALETTE = [
   "#0000FF", // blue
@@ -161,11 +152,7 @@ function createDebugLogger(namespace: string): DebugLogger {
   const colors = getColorForNamespace(namespace)
 
   return (...args: unknown[]) => {
-    // Check if enabled via environment variable or programmatically
-    const envEnabled = isEnabled(namespace)
-    const progEnabled = enabledNamespaces.has(namespace) && !disabledNamespaces.has(namespace)
-
-    if (envEnabled || progEnabled) {
+    if (isEnabled(namespace)) {
       if (isNode) {
         // Node.js: use ANSI color codes
         const coloredNamespace = `${ANSI_BOLD}${colors.ansi}${namespace}${ANSI_RESET}`
@@ -187,24 +174,3 @@ export const getLogger = (scope: string): DebugLogger => {
   const namespace = `${ROOT_NAMESPACE}:${scope}`
   return createDebugLogger(namespace)
 }
-
-export const enableDebug = (namespaces: string): void => {
-  // Parse and add namespaces to enabled set
-  const patterns = namespaces.split(/[\s,]+/).filter((p) => p.length > 0)
-  for (const pattern of patterns) {
-    if (pattern.startsWith("-")) {
-      // Remove from enabled, add to disabled
-      const namespace = pattern.slice(1)
-      enabledNamespaces.delete(namespace)
-      disabledNamespaces.add(namespace)
-    } else {
-      enabledNamespaces.add(pattern)
-      disabledNamespaces.delete(pattern)
-    }
-  }
-}
-
-export const disableDebug = (): void => {
-  enabledNamespaces.clear()
-  disabledNamespaces.clear()
-}

package/src/utils/revert.test.ts

@@ -65,6 +65,31 @@ describe("describeEntityRevert", () => {
     })
   })
 
+  describe("the indexed flag", () => {
+    it("says an indexed bytes attribute is the problem, not an unknown type", () => {
+      // bytes is typeId 7; bit 7 is the indexed flag.
+      expect(describeEntityRevert(reverted("InvalidValueType", [ident("body"), 0x87]))).toBe(
+        '"body" is a bytes attribute flagged as indexed, and bytes are stored but never indexed',
+      )
+    })
+
+    it("names the type and the flag when the node refuses an indexed attribute", () => {
+      // str is typeId 8; with bit 7 set, a node that predates the flag sees 0x88.
+      const message = describeEntityRevert(reverted("InvalidValueType", [ident("category"), 0x88]))
+      expect(message).toContain('"category" has type str and is flagged as indexed (type id 136)')
+      expect(message).toContain("may not support the indexed flag")
+    })
+    it("names the type when the node refuses an unindexed one", () => {
+      const message = describeEntityRevert(reverted("InvalidValueType", [ident("title"), 0x08]))
+      expect(message).toContain('"title" has type str (type id 8), which the node does not accept')
+    })
+    it("still reports a type id it cannot read as unknown", () => {
+      expect(describeEntityRevert(reverted("InvalidValueType", [ident("x"), 0xff]))).toContain(
+        "type id 255, which is not a known type",
+      )
+    })
+  })
+
   describe("entity state", () => {
     it("abbreviates the key so it does not bury the sentence", () => {
       const message = describeEntityRevert(reverted("EntityNotFound", [KEY]))

package/src/utils/revert.ts

@@ -1,4 +1,6 @@
 import { BaseError, ContractFunctionRevertedError, type Hex, hexToString } from "viem"
+// Internal seam: the typeId layout is the protocol's, not part of the package's public surface.
+import { decodeTypeId } from "../schema/codec"
 
 /**
  * Turns a decoded engine revert into a sentence that says what to change.
@@ -44,8 +46,8 @@ function explain(name: string, args: readonly unknown[]): string | undefined {
     // ── the attribute list ───────────────────────────────────────────────────
     case "SystemAttributeNotWritable":
       return (
-        `"${identName(args[0])}" is owned by the engine and cannot be written. Only $payload and ` +
-        "$contentType are yours to set"
+        `"${identName(args[0])}" is owned by the engine and cannot be written. Names starting ` +
+        'with "$" are reserved for system attributes'
       )
     case "TombstoneInCreate":
       return (
@@ -55,7 +57,7 @@ function explain(name: string, args: readonly unknown[]): string | undefined {
     case "TombstoneValueNotEmpty":
       return `the tombstone for "${identName(args[0])}" carries a value; unsetting takes no value`
     case "InvalidValueType":
-      return `"${identName(args[0])}" names type id ${String(args[1])}, which is not a known type`
+      return describeInvalidType(identName(args[0]), Number(args[1]))
     case "AttributesNotSorted":
       return "attributes must be strictly ascending by name, which also makes each name unique"
     case "TooManyAttributes":
@@ -117,6 +119,29 @@ function explain(name: string, args: readonly unknown[]): string | undefined {
   }
 }
 
+/**
+ * Why the engine refused a `typeId` — an indexed `bytes`, a known type it would not take (most
+ * likely the indexed flag, on a node that predates it), or a type it does not know.
+ */
+function describeInvalidType(name: string, typeId: number): string {
+  try {
+    const { tag, indexed } = decodeTypeId(typeId)
+    if (tag === "bytes" && indexed) {
+      return `"${name}" is a bytes attribute flagged as indexed, and bytes are stored but never indexed`
+    }
+    if (indexed) {
+      return (
+        `"${name}" has type ${tag} and is flagged as indexed (type id ${typeId}), which the node ` +
+        "does not accept. The node may not support the indexed flag yet"
+      )
+    }
+    return `"${name}" has type ${tag} (type id ${typeId}), which the node does not accept`
+  } catch {
+    // Falls through to the generic reading: the low bits name no type the SDK knows either.
+  }
+  return `"${name}" names type id ${typeId}, which is not a known type`
+}
+
 /** A `bytes32` Ident32 cell as the name it holds — left-aligned, null-padded. */
 function identName(raw: unknown): string {
   if (typeof raw !== "string") return String(raw)

package/dist/attr/index.cjs

@@ -1,34 +0,0 @@
-const require_attr = require('../attr-BXTkpnoc.cjs');
-
-exports.ConflictingMutationError = require_attr.ConflictingMutationError;
-exports.DECIMAL_SCALE = require_attr.DECIMAL_SCALE;
-exports.DECIMAL_UNIT = require_attr.DECIMAL_UNIT;
-exports.I32_MAX = require_attr.I32_MAX;
-exports.I32_MIN = require_attr.I32_MIN;
-exports.InvalidAttributeNameError = require_attr.InvalidAttributeNameError;
-exports.InvalidValueError = require_attr.InvalidValueError;
-exports.MAX_ATTRIBUTES = require_attr.MAX_ATTRIBUTES;
-exports.MAX_NAME_BYTES = require_attr.MAX_NAME_BYTES;
-exports.MAX_PAYLOAD_BYTES = require_attr.MAX_PAYLOAD_BYTES;
-exports.MAX_STRING_BYTES = require_attr.MAX_STRING_BYTES;
-exports.MissingValueError = require_attr.MissingValueError;
-exports.TooManyAttributesError = require_attr.TooManyAttributesError;
-exports.U256_MAX = require_attr.U256_MAX;
-exports.U64_MAX = require_attr.U64_MAX;
-exports.UnknownAttributeTypeError = require_attr.UnknownAttributeTypeError;
-exports.UntypedValueError = require_attr.UntypedValueError;
-exports.addr = require_attr.addr;
-exports.bool = require_attr.bool;
-exports.bytes32 = require_attr.bytes32;
-exports.dec = require_attr.dec;
-exports.decFromUnits = require_attr.decFromUnits;
-exports.decUnits = require_attr.decUnits;
-exports.i32 = require_attr.i32;
-exports.isArkivValue = require_attr.isArkivValue;
-exports.isValidAttributeName = require_attr.isValidAttributeName;
-exports.key = require_attr.key;
-exports.str = require_attr.str;
-exports.toValue = require_attr.toValue;
-exports.u256 = require_attr.u256;
-exports.u64 = require_attr.u64;
-exports.validateAttributeName = require_attr.validateAttributeName;

package/dist/attr/index.d.cts

@@ -1,2 +0,0 @@
-import { A as i32, B as Bytes32Value, C as ValueInput, D as dec, E as bytes32, F as u64, G as StrValue, H as DecValue, I as AddrValue, J as U64Value, K as TypeTag, L as AnyArkivValue, M as str, N as toValue, O as decFromUnits, P as u256, R as ArkivValue, S as U64_MAX, T as bool, U as I32Value, V as BytesValue, W as KeyValue, X as isArkivValue, Y as UserTypeTag, _ as MAX_PAYLOAD_BYTES, a as InvalidAttributeNameError, b as MAX_STRING_BYTES, c as TooManyAttributesError, d as DECIMAL_SCALE, f as DECIMAL_UNIT, g as MAX_ATTRIBUTES, h as Attributes, i as ConflictingMutationError, j as key, k as decUnits, l as UnknownAttributeTypeError, m as AttributeSchema, n as isValidAttributeName, o as InvalidValueError, p as AttributeInputs, q as U256Value, r as validateAttributeName, s as MissingValueError, t as MAX_NAME_BYTES, u as UntypedValueError, v as I32_MAX, w as addr, x as U256_MAX, y as I32_MIN, z as BoolValue } from "../index-CIcHPx2j.cjs";
-export { AddrValue, AnyArkivValue, ArkivValue, AttributeInputs, AttributeSchema, Attributes, BoolValue, Bytes32Value, BytesValue, ConflictingMutationError, DECIMAL_SCALE, DECIMAL_UNIT, DecValue, I32Value, I32_MAX, I32_MIN, InvalidAttributeNameError, InvalidValueError, KeyValue, MAX_ATTRIBUTES, MAX_NAME_BYTES, MAX_PAYLOAD_BYTES, MAX_STRING_BYTES, MissingValueError, StrValue, TooManyAttributesError, TypeTag, U256Value, U256_MAX, U64Value, U64_MAX, UnknownAttributeTypeError, UntypedValueError, UserTypeTag, ValueInput, addr, bool, bytes32, dec, decFromUnits, decUnits, i32, isArkivValue, isValidAttributeName, key, str, toValue, u256, u64, validateAttributeName };

package/dist/attr/index.d.ts

@@ -1,2 +0,0 @@
-import { A as i32, B as Bytes32Value, C as ValueInput, D as dec, E as bytes32, F as u64, G as StrValue, H as DecValue, I as AddrValue, J as U64Value, K as TypeTag, L as AnyArkivValue, M as str, N as toValue, O as decFromUnits, P as u256, R as ArkivValue, S as U64_MAX, T as bool, U as I32Value, V as BytesValue, W as KeyValue, X as isArkivValue, Y as UserTypeTag, _ as MAX_PAYLOAD_BYTES, a as InvalidAttributeNameError, b as MAX_STRING_BYTES, c as TooManyAttributesError, d as DECIMAL_SCALE, f as DECIMAL_UNIT, g as MAX_ATTRIBUTES, h as Attributes, i as ConflictingMutationError, j as key, k as decUnits, l as UnknownAttributeTypeError, m as AttributeSchema, n as isValidAttributeName, o as InvalidValueError, p as AttributeInputs, q as U256Value, r as validateAttributeName, s as MissingValueError, t as MAX_NAME_BYTES, u as UntypedValueError, v as I32_MAX, w as addr, x as U256_MAX, y as I32_MIN, z as BoolValue } from "../index-Cd2aaWme.js";
-export { AddrValue, AnyArkivValue, ArkivValue, AttributeInputs, AttributeSchema, Attributes, BoolValue, Bytes32Value, BytesValue, ConflictingMutationError, DECIMAL_SCALE, DECIMAL_UNIT, DecValue, I32Value, I32_MAX, I32_MIN, InvalidAttributeNameError, InvalidValueError, KeyValue, MAX_ATTRIBUTES, MAX_NAME_BYTES, MAX_PAYLOAD_BYTES, MAX_STRING_BYTES, MissingValueError, StrValue, TooManyAttributesError, TypeTag, U256Value, U256_MAX, U64Value, U64_MAX, UnknownAttributeTypeError, UntypedValueError, UserTypeTag, ValueInput, addr, bool, bytes32, dec, decFromUnits, decUnits, i32, isArkivValue, isValidAttributeName, key, str, toValue, u256, u64, validateAttributeName };

package/dist/attr/index.js

@@ -1,3 +0,0 @@
-import { A as DECIMAL_UNIT, C as str, E as u64, F as TooManyAttributesError, I as UnknownAttributeTypeError, L as UntypedValueError, M as InvalidAttributeNameError, N as InvalidValueError, O as isArkivValue, P as MissingValueError, S as key, T as u256, _ as bytes32, a as MAX_NAME_BYTES, b as decUnits, d as I32_MIN, f as MAX_STRING_BYTES, g as bool, h as addr, j as ConflictingMutationError, k as DECIMAL_SCALE, m as U64_MAX, n as MAX_PAYLOAD_BYTES, o as isValidAttributeName, p as U256_MAX, s as validateAttributeName, t as MAX_ATTRIBUTES, u as I32_MAX, v as dec, w as toValue, x as i32, y as decFromUnits } from "../attr-tmyREHtw.js";
-
-export { ConflictingMutationError, DECIMAL_SCALE, DECIMAL_UNIT, I32_MAX, I32_MIN, InvalidAttributeNameError, InvalidValueError, MAX_ATTRIBUTES, MAX_NAME_BYTES, MAX_PAYLOAD_BYTES, MAX_STRING_BYTES, MissingValueError, TooManyAttributesError, U256_MAX, U64_MAX, UnknownAttributeTypeError, UntypedValueError, addr, bool, bytes32, dec, decFromUnits, decUnits, i32, isArkivValue, isValidAttributeName, key, str, toValue, u256, u64, validateAttributeName };