@arkiv-network/sdk 0.7.0 → 0.8.0-advanced.3

package/dist/arkivTransactions-BpARZOsH.d.cts

@@ -0,0 +1,584 @@
+import { i as SelectArg, s as Entity } from "./selection-C6KeWJ7g.cjs";
+import { p as AttributeInputs } from "./index-NbfnXxgr.cjs";
+import { n as Expiry, r as ExpiryContext } from "./expiry-DRV29F1r.cjs";
+import { d as SaltInput, m as Operation } from "./index-DZxwz2Ky.cjs";
+import { n as ResolvedCreationFlags, t as CreationFlags } from "./flags-CRjPpoh3.cjs";
+import { Address, Hash, Hex, TransactionReceipt } from "viem";
+
+//#region src/actions/public/getBlockTiming.d.ts
+type GetBlockTimingReturnType = {
+  currentBlock: bigint;
+  currentBlockTime: number;
+  blockDuration: number;
+};
+//#endregion
+//#region src/actions/public/predictEntityKeys.d.ts
+/**
+ * A key a create will be given, together with the salt that mints it.
+ *
+ * The two travel as a pair because neither is any use alone: a create defaults to a *random* salt,
+ * so the key only comes out as predicted if that same create carries this salt.
+ */
+type PredictedEntityKey = {
+  /** The key the create will be given. */
+  key: Hex;
+  /**
+   * The salt the create must carry for its key to come out as {@link PredictedEntityKey.key}.
+   * Always a plain `uint128` — a requested {@link NO_SALT} comes back as the `0n` it resolves to,
+   * which a create accepts just the same.
+   */
+  salt: bigint;
+};
+/** Parameters for `client.predictEntityKeys`. */
+type PredictEntityKeysParameters<TCount extends number = number, TSalts extends readonly SaltInput[] | undefined = readonly SaltInput[] | undefined> = {
+  /** The account that will sign the creates. Its nonce is what the keys are derived from. */
+  owner: Address;
+  /**
+   * How many creates the batch will carry. Ignored when `salts` is given, which already says how
+   * many there are.
+   *
+   * A literal count comes back as a fixed-length tuple, so `count: 2` destructures into two named
+   * pairs without a cast.
+   */
+  count?: TCount | undefined;
+  /**
+   * The salt each create will carry, in batch order. Defaults to `count` fresh random salts —
+   * either way each key comes back paired with the salt that mints it. Pass {@link NO_SALT} in a
+   * slot whose create opts out of salting.
+   */
+  salts?: TSalts;
+};
+/**
+ * The keys a batch would mint, in batch order, each paired with its salt.
+ *
+ * The length follows the request whenever it is known statically: a literal `count`, or a `salts`
+ * tuple, gives a fixed-length tuple; a count computed at runtime gives a plain array.
+ *
+ * `TSalts` is wrapped in a tuple to stop the conditional distributing over it. Left naked, the
+ * `readonly SaltInput[] | undefined` default would take both branches and union a tuple with an
+ * array, which widens the length straight back to `number`.
+ */
+type PredictEntityKeysReturnType<TCount extends number = number, TSalts extends readonly SaltInput[] | undefined = readonly SaltInput[] | undefined> = [TSalts] extends [readonly SaltInput[]] ? { -readonly [Index in keyof TSalts]: PredictedEntityKey } : Repeat<PredictedEntityKey, TCount>;
+/**
+ * A tuple of `TLength` × `T`, or a plain array when the length is only known at runtime.
+ *
+ * Written tail-recursively so TypeScript can build the batch sizes anyone would actually send.
+ */
+type Repeat<T, TLength extends number, TAcc extends T[] = []> = number extends TLength ? T[] : TAcc["length"] extends TLength ? TAcc : Repeat<T, TLength, [...TAcc, T]>;
+/**
+ * Works out the keys an account's next creates will be given, before sending them.
+ *
+ * A key is `keccak256(chainId ++ registry ++ owner ++ nonce ++ salt)`. Everything but the nonce is
+ * known to the caller, and the nonce is read here — so a batch can reference a key it is about to
+ * mint, storing it as a `key` attribute on a sibling entity created in the same transaction.
+ *
+ * Each key arrives paired with its salt, and the create must be given that salt: a create left to
+ * pick its own salt picks a random one, which mints a different key.
+ *
+ * The prediction is valid only while nothing else from this owner is in flight. Every create that
+ * lands first takes the nonce with it and moves these keys. For a key you can rely on
+ * unconditionally, read it back from the create instead — `createEntity` and `executeBatch`
+ * report the keys the engine actually minted.
+ *
+ * @param parameters - Owner, and either a count or the salts. {@link PredictEntityKeysParameters}
+ * @returns One `{ key, salt }` pair per create, in batch order. {@link PredictEntityKeysReturnType}
+ *
+ * @example A batch whose second entity points at its first.
+ * import { key } from "@arkiv-network/sdk/attr"
+ *
+ * const [parent, child] = await client.predictEntityKeys({ owner: account.address, count: 2 })
+ * await client.executeBatch({
+ *   creates: [
+ *     { payload, contentType, expires, salt: parent.salt },
+ *     {
+ *       payload,
+ *       contentType,
+ *       expires,
+ *       salt: child.salt,
+ *       attributes: { parent: key(parent.key) },
+ *     },
+ *   ],
+ * })
+ */
+//#endregion
+//#region src/actions/public/query.d.ts
+type QueryOptions = {
+  /** What to return. Defaults to everything. */
+  select?: SelectArg | undefined;
+  /** Block height to read at. Defaults to the head. */
+  atBlock?: bigint | undefined;
+  /** Page size, up to the node maximum of 200. */
+  limit?: number | undefined;
+  /**
+   * Cursor from a previous page. Requires that page's `blockNumber` as {@link atBlock} alongside
+   * it — the cursor is bound to the block it was issued at, so persist the two together. A cursor
+   * without a block is rejected locally rather than left to fail whenever a block lands mid-walk.
+   */
+  cursor?: string | undefined;
+};
+type QueryReturnType = {
+  entities: Entity[];
+  /** The cursor for the next page, or `undefined` when no pages remain. */
+  cursor: string | undefined;
+  /** The block the page was read at. */
+  blockNumber: bigint;
+};
+//#endregion
+//#region src/types/events.d.ts
+/**
+ * Where an event sits in the chain — carried by every on-chain entity event.
+ *
+ * Operations apply in batch order and emit one event each, so `blockNumber` and `logIndex` together
+ * are the order the operations were applied in. A replica that replays them in that order sees
+ * exactly what the engine did.
+ */
+type EntityEventContext = {
+  /** The block the operation was applied in. */
+  blockNumber: bigint;
+  /** The transaction the operation was part of. */
+  transactionHash: Hex;
+  /** The event's position within its block. */
+  logIndex: number;
+};
+/** An entity was created. */
+type EntityCreatedEvent = EntityEventContext & {
+  type: "EntityCreated";
+  entityKey: Hex;
+  owner: Address;
+  /** The block the entity is set to expire at. */
+  expiresAt: bigint;
+  /**
+   * The immutable properties the entity was created with, decoded from its `creationFlags` byte.
+   */
+  creationFlags: ResolvedCreationFlags;
+};
+/**
+ * An entity's attributes or payload changed.
+ *
+ * The event says *that* it changed, not what to — read the entity to see the new state.
+ */
+type EntityPatchedEvent = EntityEventContext & {
+  type: "EntityPatched";
+  entityKey: Hex;
+  owner: Address;
+};
+/** An entity's expiry moved further out. */
+type ExpiryExtendedEvent = EntityEventContext & {
+  type: "ExpiryExtended";
+  entityKey: Hex;
+  /**
+   * The entity's owner — **not** whoever extended it. An entity created with
+   * `permissionlessExtension` can be extended by anyone, and the event does not say by whom; read
+   * the transaction's sender if you need that.
+   */
+  owner: Address;
+  /** The block the entity is now set to expire at. */
+  expiresAt: bigint;
+};
+/** An entity changed hands. */
+type OwnershipTransferredEvent = EntityEventContext & {
+  type: "OwnershipTransferred";
+  entityKey: Hex;
+  previousOwner: Address;
+  newOwner: Address;
+};
+/** An entity was deleted by its owner, before its expiry. */
+type EntityDeletedEvent = EntityEventContext & {
+  type: "EntityDeleted";
+  entityKey: Hex;
+  owner: Address;
+};
+/**
+ * Every event the engine emits, discriminated by `type`.
+ */
+type EntityEvent = EntityCreatedEvent | EntityPatchedEvent | ExpiryExtendedEvent | OwnershipTransferredEvent | EntityDeletedEvent;
+//#endregion
+//#region src/actions/public/watchEntityEvents.d.ts
+/**
+ * Handlers and options for `client.watchEntityEvents`. Every handler is optional; the watcher does
+ * the work for the ones you pass.
+ */
+type WatchEntityEventsParameters = {
+  onEntityCreated?: ((event: EntityCreatedEvent) => void) | undefined;
+  onEntityPatched?: ((event: EntityPatchedEvent) => void) | undefined;
+  onExpiryExtended?: ((event: ExpiryExtendedEvent) => void) | undefined;
+  onOwnershipTransferred?: ((event: OwnershipTransferredEvent) => void) | undefined;
+  onEntityDeleted?: ((event: EntityDeletedEvent) => void) | undefined;
+  /**
+   * Every event, in application order, whatever its type. Runs *before* the per-event handler for
+   * the same event.
+   *
+   * This is the replay seam: operations apply in batch order and emit one event each, so an
+   * off-chain replica that consumes this in order sees exactly what the engine did.
+   */
+  onEvent?: ((event: EntityEvent) => void) | undefined;
+  /**
+   * Transport failures, logs that will not decode, and anything one of your own handlers throws.
+   *
+   * Defaults to `console.error`. A watcher whose filter the node dropped otherwise just goes quiet,
+   * and a quiet watcher is indistinguishable from a quiet chain.
+   */
+  onError?: ((error: Error) => void) | undefined;
+  /** Replay from this block before following the head. Defaults to the head. */
+  fromBlock?: bigint | undefined;
+  /** How often to poll, in milliseconds. Defaults to half a block. */
+  pollingInterval?: number | undefined;
+};
+//#endregion
+//#region src/actions/wallet/createEntity.d.ts
+/**
+ * Parameters for creating an entity.
+ *
+ * An entity always carries contents and a type for them, plus a lifetime. Attributes, flags and a
+ * salt are optional on top of that.
+ *
+ * @example
+ * const { entityKey } = await client.createEntity({
+ *   attributes: {
+ *     level:   i32(10),
+ *     balance: u256(1_000_000n),
+ *     score:   dec("3.5"),
+ *     name:    "Bob",   // bare string -> str
+ *     flagged: true,    // bare boolean -> bool
+ *   },
+ *   payload: jsonToPayload({ hello: "world" }),
+ *   contentType: "application/json",
+ *   expires: ExpirationTime.fromDays(30),
+ *   flags: { readonly: true },
+ * })
+ *
+ * @example Pin an absolute deadline, but refuse to create something nearly dead:
+ * await client.createEntity({
+ *   payload, contentType: "application/json",
+ *   expires: ExpirationTime.atDate(someDeadline, {
+ *     atLeast: ExpirationTime.fromDays(1),    // ...but live at least a day regardless
+ *   }),
+ * })
+ *
+ * @example An entity that is nothing but queryable attributes still declares its (empty) contents:
+ * await client.createEntity({
+ *   attributes: { parent: key(parentKey), rank: i32(3) },
+ *   payload: new Uint8Array(),
+ *   contentType: "application/octet-stream",
+ *   expires: ExpirationTime.fromDays(30),
+ * })
+ */
+type CreateEntityParameters = {
+  /**
+   * How long the entity should live, built with {@link ExpirationTime}.
+   *
+   * `ExpirationTime.fromDays(30)` is the everyday form. `atBlock` / `atDate` pin an absolute
+   * deadline instead, and either can carry `{ atLeast }` to guarantee a minimum life on top of it.
+   */
+  expires: Expiry;
+  /**
+   * The entity's opaque payload. Travels to the engine as the `$payload` system attribute; on this
+   * surface it is just the entity's contents.
+   *
+   * Pass an empty `Uint8Array` for an entity that is nothing but queryable attributes — it is
+   * written as an empty payload rather than left unset, so what you pass is what is stored.
+   */
+  payload: Uint8Array;
+  /** The payload's MIME type, e.g. `"application/json"`. Sent as the `$contentType` cell. */
+  contentType: MimeType | (string & {});
+  /**
+   * The entity's queryable attributes, keyed by name. Values are the tagged constructors from
+   * `@arkiv-network/sdk/attr` — `i32`, `u64`, `u256`, `dec`, `str`, `addr`, `key`, `bytes32`,
+   * `bool` — or a bare `boolean`, `number`, `bigint` or `string` where the type is unambiguous.
+   *
+   * @throws {InvalidAttributeNameError} If a name violates the attribute-name grammar.
+   * @throws {InvalidValueError} If a value does not fit the type it names or defaults to.
+   */
+  attributes?: AttributeInputs | undefined;
+  /**
+   * Properties fixed at creation: `readonly` and `permissionlessExtension`. No operation changes
+   * them afterwards, so an entity is whatever it was created as for life. Both default to `false`.
+   */
+  flags?: CreationFlags | undefined;
+  /**
+   * The salt mixed into the entity key. Defaults to 128 random bits, which makes the key
+   * unpredictable to everyone but the creator.
+   *
+   * Pass {@link NO_SALT} for a key derived from the owner and nonce alone — predictable by anyone,
+   * which is what you want only when a third party must be able to compute the key in advance.
+   */
+  salt?: SaltInput | undefined;
+};
+/**
+ * The result of creating an entity.
+ */
+type CreateEntityReturnType = {
+  /** The new entity's key. */
+  entityKey: Hex;
+  txHash: Hash;
+  /**
+   * The block the entity is expected to expire at, resolved against the block the transaction was
+   * built on.
+   *
+   * The engine resolves a duration against the block the transaction actually lands in, so for
+   * `ExpirationTime.fromDays(30)` and friends this is a lower bound: the real expiry is later by
+   * however many blocks passed between building and inclusion. An `atBlock` deadline is exact.
+   */
+  expiresAt: bigint;
+};
+//#endregion
+//#region src/actions/wallet/deleteEntity.d.ts
+/**
+ * Parameters for the deleteEntity function.
+ * - entityKey: The key of the entity to delete.
+ */
+type DeleteEntityParameters = {
+  entityKey: Hex;
+};
+/**
+ * Return type for the deleteEntity function.
+ * - entityKey: The key of the entity.
+ * - txHash: The transaction hash.
+ */
+type DeleteEntityReturnType = {
+  entityKey: Hex;
+  txHash: Hash;
+};
+//#endregion
+//#region src/actions/wallet/executeBatch.d.ts
+/**
+ * Parameters for the executeBatch function — the same batch shape the advanced path takes
+ * ({@link EntityMutationOps}), so the two surfaces cannot drift apart.
+ *
+ * At least one operation is required; a batch with nothing in it throws rather than spending gas on
+ * an empty transaction.
+ */
+type ExecuteBatchParameters = EntityMutationOps;
+/** Return type for the executeBatch function. */
+type ExecuteBatchReturnType = {
+  /** The transaction hash. */
+  txHash: Hash;
+  /** The keys of the created entities, in batch order. */
+  createdEntities: Hex[];
+  /** The keys of the patched entities. */
+  patchedEntities: Hex[];
+  /** The keys of the deleted entities. */
+  deletedEntities: Hex[];
+  /** The keys of the extended entities. */
+  extendedEntities: Hex[];
+  /** The keys of the entities handed to a new owner. */
+  ownershipChanges: Hex[];
+};
+//#endregion
+//#region src/actions/wallet/extendEntity.d.ts
+/**
+ * Parameters for extending an entity's life.
+ *
+ * An extension **sets a new expiry**; it does not add to the existing one. It is resolved exactly
+ * as a create's is — a duration counts from now, not from the entity's current expiry — so
+ * `ExpirationTime.fromDays(30)` means "alive for thirty more days from now" whatever the entity's
+ * remaining life happened to be.
+ *
+ * The engine rejects an extension that would not move the expiry later, so extending an entity by
+ * less than it already has left is an error rather than a silent shortening.
+ *
+ * @example
+ * await client.extendEntity({ entityKey, expires: ExpirationTime.fromDays(30) })
+ * await client.extendEntity({ entityKey, expires: ExpirationTime.atBlock(1_200_000n) })
+ */
+type ExtendEntityParameters = {
+  entityKey: Hex;
+  /** The entity's new lifetime, built with {@link ExpirationTime}. */
+  expires: Expiry;
+};
+/**
+ * The result of extending an entity.
+ */
+type ExtendEntityReturnType = {
+  entityKey: Hex;
+  txHash: Hash;
+  /**
+   * The block the entity is now expected to expire at, resolved against the block the transaction
+   * was built on. Durations are approximate, so treat this as the estimate the operation was built
+   * from rather than the block the engine settled on.
+   */
+  expiresAt: bigint;
+};
+//#endregion
+//#region src/actions/wallet/patchEntity.d.ts
+/**
+ * Parameters for patching an entity.
+ *
+ * A patch names only what changes. Attributes it does not mention keep whatever value they have, and
+ * the payload and content type stay as they are unless given — so a caller can change one field
+ * without first reading the entity to learn what the others are, and without racing anyone else who
+ * is changing a different field.
+ *
+ * The entity's identity is fixed: a patch never moves the key, the owner, the creation flags or the
+ * expiry. Use `extendEntity` for the expiry and `changeOwnership` for the owner.
+ *
+ * @example Change one attribute and remove another, leaving the payload alone:
+ * await client.patchEntity({
+ *   entityKey,
+ *   set: { status: "published", level: i32(11) },
+ *   unset: ["draft"],
+ * })
+ *
+ * @example Replace the contents without touching a single attribute:
+ * await client.patchEntity({
+ *   entityKey,
+ *   payload: jsonToPayload({ hello: "again" }),
+ * })
+ */
+type PatchEntityParameters = {
+  /** The entity to patch. */
+  entityKey: Hex;
+  /**
+   * Attributes to write, keyed by name. An existing attribute is overwritten — including with a
+   * different type — and a name the entity does not carry yet is added.
+   *
+   * Values are the tagged constructors from `@arkiv-network/sdk/attr` — `i32`, `u64`, `u256`,
+   * `dec`, `str`, `addr`, `key`, `bytes32`, `bool` — or a bare `boolean`, `number`, `bigint` or
+   * `string` where the type is unambiguous.
+   *
+   * @throws {InvalidAttributeNameError} If a name violates the attribute-name grammar.
+   * @throws {InvalidValueError} If a value does not fit the type it names or defaults to.
+   */
+  set?: AttributeInputs | undefined;
+  /**
+   * Attribute names to remove. Naming one the entity does not carry is not an error — the outcome
+   * is the same either way, and a caller clearing a field should not have to know whether it was
+   * ever set.
+   *
+   * @throws {ConflictingMutationError} If a name also appears in `set`.
+   */
+  unset?: readonly string[] | undefined;
+  /**
+   * The entity's new payload. Omit it to leave the current contents untouched; pass an empty
+   * `Uint8Array` to replace them with nothing.
+   */
+  payload?: Uint8Array | undefined;
+  /**
+   * The payload's new MIME type. Omit it to keep the current one — which is what you want when the
+   * new payload is the same kind of thing as the old.
+   */
+  contentType?: MimeType | (string & {}) | undefined;
+};
+/** The result of patching an entity. */
+type PatchEntityReturnType = {
+  /** The patched entity's key — unchanged, since a patch never moves it. */
+  entityKey: Hex;
+  txHash: Hash;
+};
+//#endregion
+//#region src/types/mimeTypes.d.ts
+type MimeType = "text/plain" | "text/html" | "text/css" | "text/csv" | "text/xml" | "text/javascript" | "application/json" | "application/xml" | "application/pdf" | "application/zip" | "application/gzip" | "application/octet-stream" | "application/javascript" | "application/x-www-form-urlencoded" | "image/png" | "image/jpeg" | "image/webp" | "image/gif" | "image/svg+xml" | "audio/mpeg" | "audio/wav" | "audio/ogg" | "video/mp4" | "video/webm" | "video/ogg" | "multipart/form-data";
+//#endregion
+//#region src/types/txParams.d.ts
+/**
+ * Transaction fields a write action passes through to the wallet, for the cases where the defaults
+ * are not what you want.
+ *
+ * Fee style is either/or: give `gasPrice` for a legacy transaction, or `maxFeePerGas` /
+ * `maxPriorityFeePerGas` for an EIP-1559 one. Mixing the two does not typecheck. Anything left out
+ * is estimated.
+ */
+type TxParams = {
+  gas?: bigint;
+  nonce?: number;
+  gasPrice?: bigint;
+  maxFeePerGas?: never;
+  maxPriorityFeePerGas?: never;
+} | {
+  gas?: bigint;
+  nonce?: number;
+  maxFeePerGas?: bigint;
+  maxPriorityFeePerGas?: bigint;
+  gasPrice?: never;
+};
+//#endregion
+//#region src/actions/wallet/changeOwnership.d.ts
+/**
+ * Parameters for the changeOwnership function.
+ * - entityKey: The key of the entity.
+ * - newOwner: The address of the new owner.
+ */
+type ChangeOwnershipParameters = {
+  entityKey: Hex;
+  newOwner: Hex;
+};
+/**
+ * Return type for the changeOwnership function.
+ * - entityKey: The key of the entity.
+ * - txHash: The transaction hash.
+ */
+type ChangeOwnershipReturnType = {
+  entityKey: Hex;
+  txHash: Hash;
+};
+//#endregion
+//#region src/utils/arkivTransactions.d.ts
+
+/** The five kinds of entity operation one Arkiv transaction can batch. */
+type EntityMutationOps = {
+  /** The entities to create. */
+  creates?: CreateEntityParameters[];
+  /** The patches to apply. */
+  patches?: PatchEntityParameters[];
+  /** The entities to delete. */
+  deletes?: DeleteEntityParameters[];
+  /** The expiries to set. */
+  extensions?: ExtendEntityParameters[];
+  /** The ownership transfers to perform. */
+  ownershipChanges?: ChangeOwnershipParameters[];
+};
+/**
+ * Whether encoding the batch actually requires the chain head.
+ *
+ * Only a relative lifetime (`minLifetime > 0`) or a wall-clock deadline (a `Date`) is measured
+ * from the current block. A purely absolute `atBlock(n)` expiry encodes the same bytes whatever
+ * the head is, so a batch of those — or one with no expiries at all — needs no `eth_blockNumber`.
+ */
+declare function mutationNeedsBlockNumber(ops: EntityMutationOps): boolean;
+/**
+ * Encodes a batch into the `execute` operations, in the order the engine applies them: creates,
+ * patches, deletes, extensions, ownership transfers.
+ *
+ * Pure — every check here is local (content types, salts, expiry bounds, non-empty patches and a
+ * non-empty batch), so the only chain input is `context.currentBlock`. Callers that carry no
+ * relative expiry (see {@link mutationNeedsBlockNumber}) can pass `0n`, which disables the
+ * dead-on-arrival pre-check and leaves that to the engine.
+ */
+declare function buildEntityOperations(ops: EntityMutationOps, context: ExpiryContext): Operation[];
+/** Everything the batch's events say happened, one entry per applied operation, per kind. */
+type MutationEvents = {
+  created: {
+    entityKey: Hex;
+    owner: Address;
+    expiresAt: bigint;
+  }[];
+  patched: {
+    entityKey: Hex;
+    owner: Address;
+  }[];
+  deleted: {
+    entityKey: Hex;
+    owner: Address;
+  }[];
+  extended: {
+    entityKey: Hex;
+    owner: Address;
+    expiresAt: bigint;
+  }[];
+  ownershipTransferred: {
+    entityKey: Hex;
+    previousOwner: Address;
+    newOwner: Address;
+  }[];
+};
+/**
+ * Reads the entity events out of a receipt's logs, exactly as they were emitted.
+ *
+ * Lenient by design: it reports what the events say and nothing else — no counting against what
+ * was asked for (the caller may not have the request at hand) and no error for a receipt with no
+ * entity events at all. Logs from other contracts and events this SDK has no name for are skipped.
+ */
+declare function collectMutationEvents(logs: TransactionReceipt["logs"]): MutationEvents;
+//#endregion
+export { PredictEntityKeysParameters as A, EntityEvent as C, OwnershipTransferredEvent as D, ExpiryExtendedEvent as E, PredictedEntityKey as M, GetBlockTimingReturnType as N, QueryOptions as O, EntityDeletedEvent as S, EntityPatchedEvent as T, DeleteEntityReturnType as _, mutationNeedsBlockNumber as a, WatchEntityEventsParameters as b, TxParams as c, PatchEntityReturnType as d, ExtendEntityParameters as f, DeleteEntityParameters as g, ExecuteBatchReturnType as h, collectMutationEvents as i, PredictEntityKeysReturnType as j, QueryReturnType as k, MimeType as l, ExecuteBatchParameters as m, MutationEvents as n, ChangeOwnershipParameters as o, ExtendEntityReturnType as p, buildEntityOperations as r, ChangeOwnershipReturnType as s, EntityMutationOps as t, PatchEntityParameters as u, CreateEntityParameters as v, EntityEventContext as w, EntityCreatedEvent as x, CreateEntityReturnType as y };
+//# sourceMappingURL=arkivTransactions-BpARZOsH.d.cts.map

package/dist/arkivTransactions-BpARZOsH.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arkivTransactions-BpARZOsH.d.cts","names":[],"sources":["../src/actions/public/getBlockTiming.ts","../src/actions/public/predictEntityKeys.ts","../src/actions/public/query.ts","../src/types/events.ts","../src/actions/public/watchEntityEvents.ts","../src/actions/wallet/createEntity.ts","../src/actions/wallet/deleteEntity.ts","../src/actions/wallet/executeBatch.ts","../src/actions/wallet/extendEntity.ts","../src/actions/wallet/patchEntity.ts","../src/types/mimeTypes.ts","../src/types/txParams.ts","../src/actions/wallet/changeOwnership.ts","../src/utils/arkivTransactions.ts"],"sourcesContent":[],"mappings":"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"}