@arkiv-network/sdk 0.1.1-dev.0 → 0.1.3-dev.0

package/src/types/rpcSchema.ts

@@ -0,0 +1,61 @@
+import type { Hex, PublicRpcSchema } from "viem"
+import type { MimeType } from "./mimeTypes"
+
+export type RpcEntity = {
+  key: Hex
+  contentType: MimeType
+  value: string
+  expiresAt: bigint
+  owner: Hex
+  stringAttributes?: [{ key: string; value: string }]
+  numericAttributes?: [{ key: string; value: number }]
+}
+
+export type RpcQueryOptions = {
+  atBlock?: number
+  includeData?: RpcIncludeData
+  resultsPerPage?: number
+  cursor?: string
+}
+
+export type RpcIncludeData = {
+  key: boolean
+  attributes: boolean
+  payload: boolean
+  contentType: boolean
+  expiration: boolean
+  owner: boolean
+}
+
+export type ArkivRpcSchema = [
+  {
+    Method: "golembase_getStorageValue"
+    Parameters?: [entityId: Hex]
+    ReturnType: string
+  },
+  {
+    Method: "arkiv_query"
+    Parameters?: [query: string, queryOptions?: RpcQueryOptions]
+    ReturnType: {
+      data: [RpcEntity]
+      blockNumber: bigint
+      cursor: string
+    }
+  },
+  {
+    Method: "arkiv_getBlockTiming"
+    Parameters?: []
+    ReturnType: {
+      current_block: bigint
+      current_block_time: number
+      duration: number
+    }
+  },
+  {
+    Method: "arkiv_getEntityCount"
+    Parameters?: []
+    ReturnType: number
+  },
+]
+
+export type PublicArkivRpcSchema = [...PublicRpcSchema, ...ArkivRpcSchema]

package/src/types/txParams.ts

@@ -0,0 +1,15 @@
+export type TxParams =
+  | {
+      gas?: bigint
+      nonce?: number
+      gasPrice?: bigint
+      maxFeePerGas?: never
+      maxPriorityFeePerGas?: never
+    }
+  | {
+      gas?: bigint
+      nonce?: number
+      maxFeePerGas?: bigint
+      maxPriorityFeePerGas?: bigint
+      gasPrice?: never
+    }

package/src/utils/arkivTransactions.ts

@@ -0,0 +1,100 @@
+import { type Hex, toBytes, toHex, toRlp } from "viem"
+import type { ChangeOwnershipParameters } from "../actions/wallet/changeOwnership"
+import type { CreateEntityParameters } from "../actions/wallet/createEntity"
+import type { DeleteEntityParameters } from "../actions/wallet/deleteEntity"
+import type { ExtendEntityParameters } from "../actions/wallet/extendEntity"
+import type { UpdateEntityParameters } from "../actions/wallet/updateEntity"
+import type { ArkivClient } from "../clients/baseClient"
+import type { WalletArkivClient } from "../clients/createWalletClient"
+import { ARKIV_ADDRESS, BLOCK_TIME } from "../consts"
+import type { TxParams } from "../types"
+import { compress } from "./compression"
+
+export function opsToTxData({
+  creates,
+  updates,
+  deletes,
+  extensions,
+  ownershipChanges,
+}: {
+  creates?: CreateEntityParameters[]
+  updates?: UpdateEntityParameters[]
+  deletes?: DeleteEntityParameters[]
+  extensions?: ExtendEntityParameters[]
+  ownershipChanges?: ChangeOwnershipParameters[]
+}) {
+  function formatAttributes<T extends string | number | bigint | boolean>(attribute: {
+    key: string
+    value: T
+  }): [Hex, Hex] {
+    return [toHex(attribute.key), toHex(attribute.value)]
+  }
+
+  const payload = [
+    //creates
+    (creates ?? []).map((item) => [
+      toHex(item.expiresIn / BLOCK_TIME),
+      toHex(item.contentType),
+      toHex(item.payload),
+      item.attributes
+        .filter((attribute) => typeof attribute.value === "string")
+        .map(formatAttributes),
+      item.attributes
+        .filter((attribute) => typeof attribute.value === "number")
+        .map(formatAttributes),
+    ]),
+    //updates
+    (updates ?? []).map((item) => [
+      item.entityKey,
+      toHex(item.contentType),
+      toHex(item.expiresIn / BLOCK_TIME),
+      toHex(item.payload),
+      item.attributes
+        .filter((attribute) => typeof attribute.value === "string")
+        .map(formatAttributes),
+      item.attributes
+        .filter((attribute) => typeof attribute.value === "number")
+        .map(formatAttributes),
+    ]),
+    //deletes
+    (deletes ?? []).map((item) => item.entityKey),
+    //extends
+    (extensions ?? []).map((item) => [item.entityKey, toHex(item.expiresIn / BLOCK_TIME)]),
+    //ownershipChanges TODO
+    (ownershipChanges ?? []).map((item) => [item.entityKey, item.newOwner]),
+  ]
+
+  console.debug("txData to send as RLP", payload, payload.length)
+
+  return toRlp(payload)
+}
+
+export async function sendArkivTransaction(client: ArkivClient, data: Hex, txParams?: TxParams) {
+  if (!client.account) throw new Error("Account required")
+  const walletClient = client as WalletArkivClient
+
+  console.debug("Sending transaction", {
+    account: client.account,
+    chain: client.chain,
+    to: ARKIV_ADDRESS,
+    value: 0n,
+    data,
+    ...txParams,
+  })
+
+  const compressed = await compress(toBytes(data))
+  const txHash = await walletClient.sendTransaction({
+    account: client.account,
+    chain: client.chain,
+    to: ARKIV_ADDRESS,
+    value: 0n,
+    data: toHex(compressed),
+    ...txParams,
+  })
+
+  const receipt = await walletClient.waitForTransactionReceipt({ hash: txHash })
+
+  console.debug("Tx receipt", receipt)
+
+  return receipt
+}

package/src/utils/compression.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "bun:test"
+import { compress, decompress } from "./compression"
+
+describe("compression", () => {
+  it("should compress data", async () => {
+    const originalData = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    const compressed = await compress(originalData)
+
+    expect(compressed).toBeInstanceOf(Uint8Array)
+    expect(compressed.length).toBeGreaterThan(0)
+    // Compressed data should be different from original
+    expect(compressed).not.toEqual(originalData)
+  })
+
+  it("should compress data with large payload into smaller size", async () => {
+    const originalData = new Uint8Array(1000).fill(1)
+    const compressed = await compress(originalData)
+
+    expect(compressed).toBeInstanceOf(Uint8Array)
+    expect(compressed.length).toBeGreaterThan(0)
+    expect(compressed.length).toBeLessThan(originalData.length)
+  })
+
+  it("should decompress data", async () => {
+    const originalData = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    const compressed = await compress(originalData)
+    const decompressed = await decompress(compressed)
+
+    expect(decompressed).toBeInstanceOf(Uint8Array)
+    expect(decompressed).toEqual(originalData)
+  })
+})

package/src/utils/compression.ts

@@ -0,0 +1,99 @@
+// src/utils/compression.ts
+
+import type { BrotliWasmType } from "brotli-wasm"
+
+// Detect if we're in Node.js environment
+const isNode = typeof process !== "undefined" && process.versions?.node != null
+
+let zlib: typeof import("zlib") | null = null
+let brotli: BrotliWasmType | null = null
+
+// Lazy load zlib (Node.js only)
+async function getZlib(): Promise<typeof import("zlib") | null> {
+  if (!isNode) return null
+
+  if (!zlib) {
+    try {
+      zlib = await import("zlib")
+    } catch (error) {
+      console.error("Error importing zlib", error)
+      return null
+    }
+  }
+  return zlib
+}
+
+// Lazy load brotli-wasm (browser/fallback)
+async function getBrotli(): Promise<BrotliWasmType | null> {
+  if (brotli) return brotli
+
+  try {
+    const brotliModule = await import("brotli-wasm")
+    brotli = brotliModule.default || brotliModule
+  } catch (error) {
+    console.error("Error importing brotli-wasm", error)
+    return null
+  }
+
+  return brotli
+}
+
+export async function compress(data: Uint8Array): Promise<Uint8Array> {
+  console.debug(`Compressing data (size: ${data.length})`)
+
+  // Try Node.js zlib first (if available)
+  if (isNode) {
+    const zlibModule = await getZlib()
+    if (zlibModule) {
+      try {
+        // zlib.brotliCompress expects Buffer, returns Buffer
+        const buffer = Buffer.from(data)
+        const compressed = zlibModule.brotliCompressSync(buffer)
+        const result = new Uint8Array(compressed)
+        console.debug(`Brotli compressed with zlib (size: ${result.length})`)
+        return result
+      } catch (error) {
+        console.warn("zlib compression failed, falling back to brotli-wasm", error)
+      }
+    }
+  }
+
+  // Fallback to brotli-wasm (browser or if zlib fails)
+  const brotliInstance = await getBrotli()
+  if (!brotliInstance) {
+    console.warn("Brotli instance not found, not compressing data")
+    return data
+  }
+
+  const brotliCompressed = brotliInstance.compress(data)
+  console.debug(`Brotli compressed with wasm (size: ${brotliCompressed.length})`)
+  return brotliCompressed
+}
+
+export async function decompress(data: Uint8Array): Promise<Uint8Array> {
+  // Try Node.js zlib first (if available)
+  if (isNode) {
+    const zlibModule = await getZlib()
+    if (zlibModule) {
+      try {
+        // zlib.brotliDecompress expects Buffer, returns Buffer
+        const buffer = Buffer.from(data)
+        const decompressed = zlibModule.brotliDecompressSync(buffer)
+        const result = new Uint8Array(decompressed)
+        console.debug(`Brotli decompressed with zlib (size: ${result.length})`)
+        return result
+      } catch (error) {
+        console.warn("zlib decompression failed, falling back to brotli-wasm", error)
+      }
+    }
+  }
+
+  // Fallback to brotli-wasm (browser or if zlib fails)
+  const brotliInstance = await getBrotli()
+  if (!brotliInstance) {
+    console.warn("Brotli instance not found, not decompressing data")
+    return data
+  }
+
+  return brotliInstance.decompress(data)
+}

package/src/utils/entities.ts

@@ -0,0 +1,23 @@
+import { toBytes } from "viem"
+import { Entity } from "../types/entity"
+import type { RpcEntity } from "../types/rpcSchema"
+
+export async function entityFromRpcResult(rpcEntity: RpcEntity) {
+  return new Entity(
+    rpcEntity.key,
+    rpcEntity.contentType,
+    rpcEntity.owner,
+    rpcEntity.expiresAt,
+    toBytes(rpcEntity.value),
+    [
+      ...(rpcEntity.stringAttributes ?? []).map(({ key, value }) => ({
+        key,
+        value,
+      })),
+      ...(rpcEntity.numericAttributes ?? []).map(({ key, value }) => ({
+        key,
+        value: Number(value),
+      })),
+    ],
+  )
+}

package/src/utils/expirationTime.ts

@@ -0,0 +1,13 @@
+import { BLOCK_TIME } from "../consts"
+
+export const ExpirationTime = {
+  fromSeconds: (seconds: number) => seconds,
+  fromMinutes: (minutes: number) => minutes * 60,
+  fromHours: (hours: number) => hours * 60 * 60,
+  fromDays: (days: number) => days * 24 * 60 * 60,
+  fromWeeks: (weeks: number) => weeks * 7 * 24 * 60 * 60,
+  fromMonths: (months: number) => months * 30 * 24 * 60 * 60,
+  fromYears: (years: number) => years * 365 * 24 * 60 * 60,
+  fromBlocks: (blocks: number) => blocks * BLOCK_TIME,
+  fromDate: (date: Date) => Math.floor(date.getTime() / 1000) - Math.floor(Date.now() / 1000),
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "viem/utils"
+export * from "./expirationTime"
+export * from "./payload"

package/src/utils/payload.ts

@@ -0,0 +1,9 @@
+import { toBytes } from "viem"
+
+export function jsonToPayload(json: object): Uint8Array {
+  return toBytes(JSON.stringify(json))
+}
+
+export function stringToPayload(data: string): Uint8Array {
+  return toBytes(data)
+}