@arkiv-network/sdk 0.8.0-advanced.2 → 0.8.0-dev.2

package/src/actions/public/predictEntityKeys.ts

@@ -1,7 +1,13 @@
 import type { Address, Hex } from "viem"
 import { getChainId } from "viem/actions"
 import type { ArkivClient } from "../../clients/baseClient"
-import { predictEntityKey, randomSalt, validateSalt } from "../../entity/key"
+import {
+  NO_SALT,
+  predictEntityKey,
+  randomSalt,
+  resolveSalt,
+  type SaltInput,
+} from "../../entity/key"
 import { getEntityNonce } from "./getEntityNonce"
 
 /**
@@ -13,14 +19,18 @@ import { getEntityNonce } from "./getEntityNonce"
 export 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}. */
+  /**
+   * 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 {@link predictEntityKeys}. */
+/** Parameters for `client.predictEntityKeys`. */
 export type PredictEntityKeysParameters<
   TCount extends number = number,
-  TSalts extends readonly bigint[] | undefined = readonly bigint[] | undefined,
+  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
@@ -34,7 +44,8 @@ export type PredictEntityKeysParameters<
   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.
+   * 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
 }
@@ -46,13 +57,13 @@ export type PredictEntityKeysParameters<
  * 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 bigint[] | undefined` default would take both branches and union a tuple with an array,
- * which widens the length straight back to `number`.
+ * `readonly SaltInput[] | undefined` default would take both branches and union a tuple with an
+ * array, which widens the length straight back to `number`.
  */
 export type PredictEntityKeysReturnType<
   TCount extends number = number,
-  TSalts extends readonly bigint[] | undefined = readonly bigint[] | undefined,
-> = [TSalts] extends [readonly bigint[]]
+  TSalts extends readonly SaltInput[] | undefined = readonly SaltInput[] | undefined,
+> = [TSalts] extends [readonly SaltInput[]]
   ? { -readonly [Index in keyof TSalts]: PredictedEntityKey }
   : Repeat<PredictedEntityKey, TCount>
 
@@ -79,7 +90,7 @@ type Repeat<T, TLength extends number, TAcc extends T[] = []> = number extends T
  *
  * 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 `mutateEntities`
+ * 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}
@@ -89,7 +100,7 @@ type Repeat<T, TLength extends number, TAcc extends T[] = []> = number extends T
  * import { key } from "@arkiv-network/sdk/attr"
  *
  * const [parent, child] = await client.predictEntityKeys({ owner: account.address, count: 2 })
- * await wallet.mutateEntities({
+ * await client.executeBatch({
  *   creates: [
  *     { payload, contentType, expires, salt: parent.salt },
  *     {
@@ -104,7 +115,7 @@ type Repeat<T, TLength extends number, TAcc extends T[] = []> = number extends T
  */
 export async function predictEntityKeys<
   const TCount extends number = number,
-  const TSalts extends readonly bigint[] | undefined = undefined,
+  const TSalts extends readonly SaltInput[] | undefined = undefined,
 >(
   client: ArkivClient,
   { owner, count, salts }: PredictEntityKeysParameters<TCount, TSalts>,
@@ -121,12 +132,15 @@ export async function predictEntityKeys<
 }
 
 /** The salts to derive from: the ones given, or `count` fresh random ones. */
-function resolveSalts(count: number | undefined, salts: readonly bigint[] | undefined): bigint[] {
+function resolveSalts(
+  count: number | undefined,
+  salts: readonly SaltInput[] | undefined,
+): bigint[] {
   if (salts !== undefined) {
     if (salts.length === 0) {
       throw new Error("predictEntityKeys: `salts` is empty — there is nothing to predict")
     }
-    return salts.map(validateSalt)
+    return salts.map(resolveSalt)
   }
   if (count === undefined) {
     throw new Error("predictEntityKeys: pass either `count` or `salts`")

package/src/actions/public/query.ts

@@ -11,11 +11,7 @@ export type QueryOptions = {
   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 from a previous page. */
   cursor?: string | undefined
 }
 

package/src/actions/wallet/createEntity.ts

@@ -1,10 +1,11 @@
 import type { Hash, Hex } from "viem"
 import type { AttributeInputs } from "../../attr"
 import type { ArkivClient } from "../../clients/baseClient"
-import type { CreationFlags, Expiry } from "../../entity"
+import type { CreationFlags, Expiry, NO_SALT, SaltInput } from "../../entity"
 import { EntityMutationError } from "../../errors"
 import type { MimeType, TxParams } from "../../types"
 import { sendArkivTransaction } from "../../utils/arkivTransactions"
+import type { ExpirationTime } from "../../utils/expirationTime"
 import { getLogger } from "../../utils/logger"
 
 const logger = getLogger("actions:wallet:create-entity")
@@ -66,8 +67,8 @@ export type CreateEntityParameters = {
   contentType: MimeType | (string & {})
   /**
    * The entity's queryable attributes, keyed by name. Values are the tagged constructors from
-   * `@arkiv-network/sdk/attr` — `i32`, `u256`, `dec`, `str`, `addr`, `key`, `bytes32`, `bool` — or
-   * a bare `boolean`, `number`, `bigint` or `string` where the type is unambiguous.
+   * `@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.
@@ -82,10 +83,10 @@ export type CreateEntityParameters = {
    * The salt mixed into the entity key. Defaults to 128 random bits, which makes the key
    * unpredictable to everyone but the creator.
    *
-   * Pass `0n` 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.
+   * 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?: bigint | undefined
+  salt?: SaltInput | undefined
 }
 
 /**

package/src/actions/wallet/{mutateEntities.test.ts → executeBatch.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from "bun:test"
 import type { ArkivClient } from "../../clients/baseClient"
-import { mutateEntities } from "./mutateEntities"
+import { executeBatch } from "./executeBatch"
 
 const ENTITY_KEY = `0x${"ab".repeat(32)}` as const
 const NEW_OWNER = "0x2222222222222222222222222222222222222222"
@@ -29,7 +29,7 @@ describe("the empty-batch guard", () => {
     // An ownership-only batch is a batch: it used to be rejected because the guard listed
     // creates/updates/deletes/extensions and forgot ownershipChanges.
     const { client, writeContract } = makeClient()
-    const result = await mutateEntities(client, {
+    const result = await executeBatch(client, {
       ownershipChanges: [{ entityKey: ENTITY_KEY, newOwner: NEW_OWNER }],
     })
     expect(writeContract).toHaveBeenCalledTimes(1)
@@ -38,9 +38,9 @@ describe("the empty-batch guard", () => {
 
   it("rejects a batch with nothing in it", async () => {
     const { client, writeContract } = makeClient()
-    await expect(mutateEntities(client, {})).rejects.toThrow(/No operations/)
+    await expect(executeBatch(client, {})).rejects.toThrow(/No operations/)
     // Present but empty is just as empty — the engine would revert with EmptyBatch().
-    await expect(mutateEntities(client, { deletes: [], ownershipChanges: [] })).rejects.toThrow(
+    await expect(executeBatch(client, { deletes: [], ownershipChanges: [] })).rejects.toThrow(
       /No operations/,
     )
     expect(writeContract).not.toHaveBeenCalled()
@@ -52,10 +52,10 @@ describe("the empty-batch guard", () => {
     // keys would score this batch as non-empty and then drop it on the way to the wire, sending
     // execute([]) — so the guard counts the five kinds that actually reach the transaction.
     const stale = { updates: [{ entityKey: ENTITY_KEY, set: { level: 1 } }] } as never
-    await expect(mutateEntities(client, stale)).rejects.toThrow(/No operations/)
+    await expect(executeBatch(client, stale)).rejects.toThrow(/No operations/)
     // A typo is the same mistake with a different name.
     await expect(
-      mutateEntities(client, { delete: [{ entityKey: ENTITY_KEY }] } as never),
+      executeBatch(client, { delete: [{ entityKey: ENTITY_KEY }] } as never),
     ).rejects.toThrow(/No operations/)
     expect(writeContract).not.toHaveBeenCalled()
   })
@@ -65,7 +65,7 @@ describe("the empty-batch guard", () => {
     // The dangerous shape: the creates apply and the transaction succeeds, so nothing surfaces the
     // fact that the `updates` never happened. The guard cannot catch this one — only the caller's
     // types can — but the result must at least not claim they did.
-    const result = await mutateEntities(client, {
+    const result = await executeBatch(client, {
       deletes: [{ entityKey: ENTITY_KEY }],
       updates: [{ entityKey: ENTITY_KEY, set: { level: 1 } }],
     } as never)

package/src/actions/wallet/{mutateEntities.ts → executeBatch.ts}

@@ -1,22 +1,37 @@
 import type { Hash, Hex } from "viem"
 import type { ArkivClient } from "../../clients/baseClient"
 import type { TxParams } from "../../types"
-import { type EntityMutationOps, sendArkivTransaction } from "../../utils/arkivTransactions"
+import { sendArkivTransaction } from "../../utils/arkivTransactions"
 import { getLogger } from "../../utils/logger"
+import type { ChangeOwnershipParameters } from "./changeOwnership"
+import type { CreateEntityParameters } from "./createEntity"
+import type { DeleteEntityParameters } from "./deleteEntity"
+import type { ExtendEntityParameters } from "./extendEntity"
+import type { PatchEntityParameters } from "./patchEntity"
 
-const logger = getLogger("actions:wallet:mutate-entities")
+const logger = getLogger("actions:wallet:execute-batch")
 
 /**
- * Parameters for the mutateEntities function — the same batch shape the advanced path takes
- * ({@link EntityMutationOps}), so the two surfaces cannot drift apart.
+ * Parameters for the executeBatch function.
  *
  * At least one operation is required; a batch with nothing in it throws rather than spending gas on
  * an empty transaction.
  */
-export type MutateEntitiesParameters = EntityMutationOps
+export type ExecuteBatchParameters = {
+  /** 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[]
+}
 
-/** Return type for the mutateEntities function. */
-export type MutateEntitiesReturnType = {
+/** Return type for the executeBatch function. */
+export type ExecuteBatchReturnType = {
   /** The transaction hash. */
   txHash: Hash
   /** The keys of the created entities, in batch order. */
@@ -31,14 +46,14 @@ export type MutateEntitiesReturnType = {
   ownershipChanges: Hex[]
 }
 
-export async function mutateEntities(
+export async function executeBatch(
   client: ArkivClient,
-  data: MutateEntitiesParameters,
+  data: ExecuteBatchParameters,
   txParams?: TxParams,
-): Promise<MutateEntitiesReturnType> {
+): Promise<ExecuteBatchReturnType> {
   const { receipt, createdEntityKeys } = await sendArkivTransaction(client, data, txParams)
 
-  logger("Receipt from mutateEntities %o", receipt)
+  logger("Receipt from executeBatch %o", receipt)
 
   return {
     txHash: receipt.transactionHash as Hash,

package/src/actions/wallet/extendEntity.ts

@@ -4,6 +4,7 @@ import type { Expiry } from "../../entity"
 import { EntityMutationError } from "../../errors"
 import type { TxParams } from "../../types"
 import { sendArkivTransaction } from "../../utils/arkivTransactions"
+import type { ExpirationTime } from "../../utils/expirationTime"
 import { getLogger } from "../../utils/logger"
 
 const logger = getLogger("actions:wallet:extend-entity")

package/src/actions/wallet/patchEntity.ts

@@ -38,9 +38,9 @@ export type PatchEntityParameters = {
    * 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`, `u256`, `dec`, `str`,
-   * `addr`, `key`, `bytes32`, `bool` — or a bare `boolean`, `number`, `bigint` or `string` where the
-   * type is unambiguous.
+   * 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.

package/src/attr/attributes.ts

@@ -10,6 +10,10 @@ import { str, toValue, type ValueInput } from "./values"
  */
 export const MAX_ATTRIBUTES = 32
 
+/**
+ * The largest payload an entity may carry, in bytes. The payload travels as the `$payload` system
+ * cell, so this is a bound on that one attribute rather than on the operation as a whole.
+ */
 export const MAX_PAYLOAD_BYTES = 128 * 1024
 
 /** The system attribute holding an entity's opaque payload. */
@@ -20,7 +24,7 @@ const CONTENT_TYPE_CELL = "$contentType"
 /**
  * The attributes written on an entity, as a plain object keyed by attribute name.
  *
- * Values may be tagged ({@link ValueInput}) or bare where the type is unambiguous — see
+ * Values may be tagged ({@link ArkivValue}) or bare where the type is unambiguous — see
  * {@link toValue} for the bare-form defaults.
  *
  * @example
@@ -141,8 +145,10 @@ export type MutationInputs = SystemCells & {
  *
  * @throws {ConflictingMutationError} If a name appears in both `set` and `unset`.
  * @throws {InvalidAttributeNameError} If a name violates the attribute-name grammar.
+ * @throws {MissingValueError} If a value is `undefined` or `null`.
  * @throws {InvalidValueError} If a value does not fit its type.
- * @throws {TooManyAttributesError} If `set` names more than {@link MAX_ATTRIBUTES} attributes.
+ * @throws {TooManyAttributesError} If the mutations exceed {@link MAX_ATTRIBUTES}.
+ * @throws {TypeError} If `unset` is not an array.
  */
 export function encodeMutations({
   set,

package/src/attr/errors.ts

@@ -32,8 +32,8 @@ export class UntypedValueError extends Error {
   constructor(input: unknown) {
     super(
       `Cannot infer an Arkiv type for ${describe(input)}. ` +
-        "Attribute values must be a tagged value (i32, u256, dec, str, addr, key, bytes32, bool) " +
-        "or a bare boolean, number, bigint or string.",
+        "Attribute values must be a tagged value (i32, u64, u256, dec, str, addr, key, bytes32, " +
+        "bool) or a bare boolean, number, bigint or string.",
     )
     this.name = "UntypedValueError"
     this.input = input

package/src/attr/types.ts

@@ -1,4 +1,5 @@
 import type { Address, Hex } from "viem"
+import type { decUnits } from "./values"
 
 /**
  * The protocol's attribute type vocabulary, mapping each short **tag** (the name used by the
@@ -54,8 +55,7 @@ export function isUserSettable(tag: TypeTag): tag is UserTypeTag {
 /**
  * Marks a value as having passed its constructor's validation. The symbol is module-private, so a
  * hand-written object literal is not assignable to {@link ArkivValue} — every value crossing the
- * wire has been range-, length- and format-checked by {@link i32}, {@link u256}, {@link dec}, and
- * friends.
+ * wire has been range-, length- and format-checked by `i32`, `u256`, `dec`, and friends.
  */
 declare const validated: unique symbol
 
@@ -89,7 +89,7 @@ export type U256Value = Value<"u256", bigint>
 export type DecValue = Value<"dec", string>
 /** 32 opaque bytes, as lowercase `0x` hex. */
 export type Bytes32Value = Value<"bytes32", Hex>
-/** A UTF-8 string of at most 128 bytes. */
+/** A UTF-8 string of at most 128 bytes, free of C0 control characters and DEL. */
 export type StrValue = Value<"str", string>
 /** A 20-byte Ethereum address, as EIP-55 checksummed hex. */
 export type AddrValue = Value<"addr", Address>

package/src/attr/values.ts

@@ -271,7 +271,11 @@ export function decFromUnits(units: bigint): DecValue {
  *
  * The limit is on **bytes**, not characters: a string of 128 emoji does not fit.
  *
- * @throws {InvalidValueError} If the string exceeds 128 UTF-8 bytes.
+ * C0 control characters and DEL are rejected: the query language writes a `str` as `str('...')`,
+ * whose only escape is a doubled quote, so a control character could be stored but never queried.
+ *
+ * @throws {InvalidValueError} If the value is not a string, holds a control character, or exceeds
+ * 128 UTF-8 bytes.
  *
  * @example
  * str("Bob")

package/src/chains/localhost.ts

@@ -1,5 +1,8 @@
 import { defineChain } from "viem"
 
+/**
+ * A node running on the local machine
+ */
 export const localhost = defineChain({
   id: 1337,
   name: "Localhost",

package/src/clients/createPublicClient.test.ts

@@ -35,5 +35,5 @@ test("creates", () => {
   expect(client.deleteEntity).not.toBeDefined()
   expect(client.extendEntity).not.toBeDefined()
   expect(client.changeOwnership).not.toBeDefined()
-  expect(client.mutateEntities).not.toBeDefined()
+  expect(client.executeBatch).not.toBeDefined()
 })

package/src/clients/createPublicClient.ts

@@ -23,14 +23,14 @@ export type PublicArkivClient<
 >
 
 /**
- * Creates a Public Client with a given [Transport](https://viem.sh/docs/clients/intro) configured for a [Chain](https://viem.sh/docs/clients/chains).
+ * Creates a Public Client with a given [Transport](https://viem.sh/docs/clients/intro) configured for a [Chain](https://viem.sh/docs/chains/introduction).
  *
- * - Docs: https://docs.arkiv.network/ts-sdk/clients/public
- *
- * A Public Client is an interface to "public" [Ethereum JSON-RPC API](https://ethereum.org/en/developers/docs/apis/json-rpc/), [Arkiv JSON-RPC API](https://docs.arkiv.network/json-rpc/), and [Cheesecake JSON-RPC API](https://rpc.cheesecake.db-chain.devnet.gobas.me) methods such as retrieving block numbers, transactions, reading from smart contracts, etc through [Public Actions](/docs/actions/public/introduction).
+ * A Public Client is an interface to the "public" [Ethereum JSON-RPC API](https://ethereum.org/en/developers/docs/apis/json-rpc/)
+ * and the Arkiv JSON-RPC API — retrieving block numbers and transactions, reading from
+ * contracts, and querying entities — through {@link PublicArkivActions}.
  *
  * @param parameters - Configuration object for the public client (chain, transport, etc.)
- * @returns A Arkiv Public Client. {@link PublicArkivClient}
+ * @returns An Arkiv Public Client. {@link PublicArkivClient}
  *
  * @example
  * import { createPublicClient } from "@arkiv-network/sdk"

package/src/clients/createWalletClient.test.ts

@@ -29,6 +29,6 @@ test("creates", () => {
   expect(typeof client.extendEntity).toBe("function")
   expect(client.changeOwnership).toBeDefined()
   expect(typeof client.changeOwnership).toBe("function")
-  expect(client.mutateEntities).toBeDefined()
-  expect(typeof client.mutateEntities).toBe("function")
+  expect(client.executeBatch).toBeDefined()
+  expect(typeof client.executeBatch).toBe("function")
 })

package/src/clients/createWalletClient.ts

@@ -24,16 +24,14 @@ export type WalletArkivClient<
 
 /**
  * Creates a Wallet Client with a given [Transport](https://viem.sh/docs/clients/intro) configured
- * for a [Chain](https://viem.sh/docs/clients/chains) and an account.
- *
- * - Docs: https://docs.arkiv.network/ts-sdk/clients/wallet
+ * for a [Chain](https://viem.sh/docs/chains/introduction) and an account.
  *
  * A Wallet Client signs and sends transactions, so it carries an `account` and exposes everything
  * that mutates state — `createEntity`, `patchEntity`, `deleteEntity`, `extendEntity`,
- * `changeOwnership` and `mutateEntities` — on top of the read actions a Public Client has.
+ * `changeOwnership` and `executeBatch` — on top of the read actions a Public Client has.
  *
  * @param parameters - Configuration object for the wallet client (chain, transport, account, etc.)
- * @returns A Arkiv Wallet Client. {@link WalletArkivClient}
+ * @returns An Arkiv Wallet Client. {@link WalletArkivClient}
  *
  * @example
  * import { createWalletClient } from "@arkiv-network/sdk"

package/src/clients/decorators/arkivPublic.ts

@@ -1,5 +1,5 @@
 import type { Account, Address, Chain, Client, Hex, PublicActions, Transport } from "viem"
-import { getBlockTiming } from "../../actions/public/getBlockTiming"
+import { type GetBlockTimingReturnType, getBlockTiming } from "../../actions/public/getBlockTiming"
 import { getEntity } from "../../actions/public/getEntity"
 import { getEntityCount } from "../../actions/public/getEntityCount"
 import { getEntityNonce } from "../../actions/public/getEntityNonce"
@@ -13,11 +13,11 @@ import {
   type WatchEntityEventsParameters,
   watchEntityEvents,
 } from "../../actions/public/watchEntityEvents"
+import type { SaltInput } from "../../entity/key"
 import type { Expression } from "../../query/expression"
 import { SelectQueryBuilder } from "../../query/queryBuilder"
 import type { EntitySelection, FullEntity, ProjectedEntity, SelectArg } from "../../query/selection"
 import type { Entity } from "../../types/entity"
-import { type PublicAdvancedActions, publicAdvancedActions } from "./arkivAdvanced"
 
 export type PublicArkivActions<
   transport extends Transport = Transport,
@@ -39,11 +39,15 @@ export type PublicArkivActions<
   /**
    * Returns the entity with the given key.
    *
-   * - Docs: https://docs.arkiv.network/ts-sdk/actions/public/getEntity
+   * - JSON-RPC Methods: `arkiv_query`
    *
    * @param key - The entity key (hex string)
    * @returns The entity with the given key, with every field populated. {@link FullEntity}
    *
+   * @throws {InvalidValueError} If the key is not 32 bytes.
+   * @throws {NoEntityFoundError} If no live entity has that key — it never existed, or it was
+   * deleted or has expired.
+   *
    * @example
    * import { createPublicClient } from "@arkiv-network/sdk"
    * import { cheesecake } from "@arkiv-network/sdk/chains"
@@ -70,7 +74,7 @@ export type PublicArkivActions<
    * read entities. You declare up front which parts of an entity you want returned, so results
    * always contain exactly the data you asked for.
    *
-   * - Docs: https://docs.arkiv.network/ts-sdk/actions/public/query
+   * - JSON-RPC Methods: `arkiv_query`
    *
    * @param selection - What to include in the results. Omit it (or pass `"*"`) to select everything,
    *   or pass an object to select specific parts (at least one field is required). Every part is
@@ -131,7 +135,7 @@ export type PublicArkivActions<
   /**
    * Runs one query and returns one page, with no builder in between.
    *
-   * Use {@link select} for anything typed — this returns full {@link Entity} objects whatever the
+   * Use {@link PublicArkivActions.select} for anything typed — this returns full {@link Entity} objects whatever the
    * selection, and takes a raw string as an escape hatch for a query built elsewhere. A raw string
    * goes to the node exactly as written, with none of the name, type or operator checks the
    * expression combinators apply.
@@ -225,7 +229,7 @@ export type PublicArkivActions<
    * import { key } from "@arkiv-network/sdk/attr"
    *
    * const [parent, child] = await client.predictEntityKeys({ owner: account.address, count: 2 })
-   * await wallet.mutateEntities({
+   * await wallet.executeBatch({
    *   creates: [
    *     { payload, contentType, expires, salt: parent.salt },
    *     {
@@ -240,7 +244,7 @@ export type PublicArkivActions<
    */
   predictEntityKeys: <
     const TCount extends number = number,
-    const TSalts extends readonly bigint[] | undefined = undefined,
+    const TSalts extends readonly SaltInput[] | undefined = undefined,
   >(
     parameters: PredictEntityKeysParameters<TCount, TSalts>,
   ) => Promise<PredictEntityKeysReturnType<TCount, TSalts>>
@@ -265,11 +269,7 @@ export type PublicArkivActions<
    * //   blockDuration: 2, // in seconds
    * // }
    */
-  getBlockTiming: () => Promise<{
-    currentBlock: bigint
-    currentBlockTime: number
-    blockDuration: number
-  }>
+  getBlockTiming: () => Promise<GetBlockTimingReturnType>
 
   /**
    * Watches entity events, calling the handlers you pass as they arrive.
@@ -298,16 +298,6 @@ export type PublicArkivActions<
    * unwatch() // stop watching
    */
   watchEntityEvents: (parameters: WatchEntityEventsParameters) => () => void
-
-  /**
-   * The read-only half of the advanced path: check on a transaction and decode its result with at
-   * most one RPC call per action — so a process that holds nothing but a transaction hash can
-   * follow it without a wallet. {@link PublicAdvancedActions}
-   *
-   * @example
-   * const { status } = await client.advanced.pingTransaction(txHash) // 1 eth_getTransactionReceipt
-   */
-  advanced: PublicAdvancedActions
 }
 
 export function publicArkivActions<
@@ -325,12 +315,11 @@ export function publicArkivActions<
     getEntityNonce: (owner: Address) => getEntityNonce(client, owner),
     predictEntityKeys: <
       const TCount extends number = number,
-      const TSalts extends readonly bigint[] | undefined = undefined,
+      const TSalts extends readonly SaltInput[] | undefined = undefined,
     >(
       parameters: PredictEntityKeysParameters<TCount, TSalts>,
     ) => predictEntityKeys(client, parameters),
     watchEntityEvents: (parameters: WatchEntityEventsParameters) =>
       watchEntityEvents(client, parameters),
-    advanced: publicAdvancedActions(client),
   }
 }