@milaboratories/pl-client 3.2.4 → 3.3.0

package/src/core/types.ts

@@ -1,42 +1,27 @@
+import type { Branded } from "@milaboratories/pl-model-common";
 import { cachedDeserialize, notEmpty } from "@milaboratories/ts-helpers";
 
-// more details here: https://egghead.io/blog/using-branded-types-in-typescript
-declare const __resource_id_type__: unique symbol;
-type BrandResourceId<B> = bigint & { [__resource_id_type__]: B };
+/** Null resource id */
+export type NullResourceId = Branded<bigint, "null", "__resource_id__">;
 
 /** Global resource id */
-export type ResourceId = BrandResourceId<"global">;
-
-/** Null resource id */
-export type NullResourceId = BrandResourceId<"null">;
+export type GlobalResourceId = Branded<bigint, "global", "__resource_id__">;
 
 /** Local resource id */
-export type LocalResourceId = BrandResourceId<"local">;
+export type LocalResourceId = Branded<bigint, "local", "__resource_id__">;
 
 /** Any non-null resource id */
-export type AnyResourceId = ResourceId | LocalResourceId;
-
-/** Any resource id */
-export type OptionalResourceId = NullResourceId | ResourceId;
+export type AnyResourceId = GlobalResourceId | LocalResourceId;
 
 /** All possible resource flavours */
-export type OptionalAnyResourceId = NullResourceId | ResourceId | LocalResourceId;
+export type OptionalAnyResourceId = NullResourceId | GlobalResourceId | LocalResourceId;
 
 export const NullResourceId = 0n as NullResourceId;
 
-export function isNullResourceId(resourceId: bigint): resourceId is NullResourceId {
+function isNullResourceId(resourceId: bigint | string): resourceId is NullResourceId {
   return resourceId === NullResourceId;
 }
 
-export function isNotNullResourceId(resourceId: OptionalResourceId): resourceId is ResourceId {
-  return resourceId !== NullResourceId;
-}
-
-export function ensureResourceIdNotNull(resourceId: OptionalResourceId): ResourceId {
-  if (!isNotNullResourceId(resourceId)) throw new Error("null resource id");
-  return resourceId;
-}
-
 export function isAnyResourceId(resourceId: bigint): resourceId is AnyResourceId {
   return resourceId !== 0n;
 }
@@ -64,21 +49,29 @@ export function resourceTypeToString(rt: ResourceType): string {
   return `${rt.name}:${rt.version}`;
 }
 
+export function parseResourceType(str: string): ResourceType {
+  const [name, version] = str.split(":");
+  return { name, version };
+}
+
 export function resourceTypesEqual(type1: ResourceType, type2: ResourceType): boolean {
   return type1.name === type2.name && type1.version === type2.version;
 }
 
+/** Color proof used for resource creation requests (alias for ResourceSignature). */
+export type ColorProof = ResourceSignature;
+
 /** Readonly fields here marks properties of resource that can't change according to pl's state machine. */
 export type BasicResourceData = {
-  readonly id: ResourceId;
-  readonly originalResourceId: OptionalResourceId;
+  readonly id: SignedResourceId;
+  readonly originalResourceId: OptionalSignedResourceId;
 
   readonly kind: ResourceKind;
   readonly type: ResourceType;
 
   readonly data?: Uint8Array;
 
-  readonly error: OptionalResourceId;
+  readonly error: OptionalSignedResourceId;
 
   readonly inputsLocked: boolean;
   readonly outputsLocked: boolean;
@@ -132,8 +125,8 @@ export type FieldData = {
   readonly name: string;
   readonly type: FieldType;
   readonly status: FieldStatus;
-  readonly value: OptionalResourceId;
-  readonly error: OptionalResourceId;
+  readonly value: OptionalSignedResourceId;
+  readonly error: OptionalSignedResourceId;
 
   /** True if value the fields points to is in final state. */
   readonly valueIsFinal: boolean;
@@ -164,7 +157,11 @@ export function isRootResourceId(id: bigint) {
   return (id & ResourceIdRootMask) !== 0n;
 }
 
-export function isLocalResourceId(id: bigint): id is LocalResourceId {
+export function isLocalResourceId(id: bigint | string): id is LocalResourceId {
+  if (typeof id === "string") {
+    return false;
+  }
+
   return (id & ResourceIdLocalMask) !== 0n;
 }
 
@@ -186,8 +183,8 @@ export function createLocalResourceId(
     (BigInt(localTxId) << LocalResourceIdTxIdOffset)) as LocalResourceId;
 }
 
-export function createGlobalResourceId(isRoot: boolean, unmaskedId: bigint): ResourceId {
-  return ((isRoot ? ResourceIdRootMask : 0n) | unmaskedId) as ResourceId;
+export function createGlobalResourceId(isRoot: boolean, unmaskedId: bigint): GlobalResourceId {
+  return ((isRoot ? ResourceIdRootMask : 0n) | unmaskedId) as GlobalResourceId;
 }
 
 export function extractTxId(localResourceId: LocalResourceId): number {
@@ -202,8 +199,17 @@ export function checkLocalityOfResourceId(resourceId: AnyResourceId, expectedTxI
     );
 }
 
-export function resourceIdToString(resourceId: OptionalAnyResourceId): string {
+export function resourceIdToString(
+  resourceId: OptionalAnyResourceId | OptionalSignedResourceId,
+): string {
+  if (isSignedResourceId(resourceId)) {
+    // Strip signature
+    resourceId = anyResourceIdToBigint(resourceId) as GlobalResourceId;
+  }
+
+  if (isNullSignedResourceId(resourceId)) return "XX:0x0";
   if (isNullResourceId(resourceId)) return "XX:0x0";
+
   if (isLocalResourceId(resourceId))
     return (
       (isRootResourceId(resourceId) ? "R" : "N") +
@@ -234,16 +240,116 @@ export function resourceIdFromString(str: string): OptionalAnyResourceId | undef
   else return createGlobalResourceId(rn === "R", BigInt("0x" + rid));
 }
 
-/** Converts bigint to global resource id */
-export function bigintToResourceId(resourceId: bigint): ResourceId {
-  if (isLocalResourceId(resourceId))
-    throw new Error(`Local resource id: ${resourceIdToString(resourceId)}`);
-  if (isNullResourceId(resourceId)) throw new Error(`Null resource id.`);
-  return resourceId as ResourceId;
+export function anyResourceIdToBigint(resourceId: bigint | SignedResourceId): bigint {
+  if (typeof resourceId !== "string") {
+    return resourceId;
+  }
+
+  const parsed = parseSignedResourceId(resourceId);
+  return parsed.globalId as bigint;
 }
 
 export function stringifyWithResourceId(object: unknown): string {
-  return JSON.stringify(object, (key, value) =>
-    typeof value === "bigint" ? resourceIdToString(value as OptionalAnyResourceId) : value,
-  );
+  return JSON.stringify(object, (key, value) => {
+    if (typeof value === "bigint") return resourceIdToString(value as OptionalAnyResourceId);
+    if (isSignedResourceId(value)) return resourceIdToString(value);
+    return value;
+  });
+}
+
+/** Opaque authorization signature attached to a resource. */
+export type ResourceSignature = Branded<Uint8Array, "ResourceSignature">;
+
+/**
+ * Signed resource id is "<global ID>|<resource signature hex>", encoded as string
+ * (e.g. "NG:0x123EC|1234567890abcdef")
+ */
+export type SignedResourceId = Branded<string, "signed", "__signed_resource_id__">;
+
+export type NullSignedResourceId = Branded<string, "null", "__signed_resource_id__">;
+
+export const NullSignedResourceId = "" as NullSignedResourceId;
+
+/** Nullable signed resource ID */
+export type OptionalSignedResourceId = NullSignedResourceId | SignedResourceId;
+
+export function isNullSignedResourceId(
+  resourceId: bigint | string,
+): resourceId is NullSignedResourceId {
+  return resourceId === NullSignedResourceId;
+}
+
+export function isNotNullSignedResourceId(
+  resourceId: OptionalSignedResourceId,
+): resourceId is SignedResourceId {
+  // lint-allow-cast
+  return resourceId !== NullSignedResourceId;
+}
+
+export function ensureSignedResourceIdNotNull(
+  resourceId: OptionalSignedResourceId,
+): SignedResourceId {
+  if (!isNotNullSignedResourceId(resourceId)) throw new Error("null resource id");
+  return resourceId;
+}
+
+export function isSignedResourceId(resourceId: bigint | string): resourceId is SignedResourceId {
+  // lint-allow-cast
+  return typeof resourceId === "string" && resourceId.includes("|");
+}
+
+/** Encode resource signature to base64url for embedding in URL-based handles. */
+export function signatureToBase64Url(sig?: ResourceSignature): string {
+  return sig && sig.length > 0 ? Buffer.from(sig).toString("base64url") : "";
+}
+
+/** Cast raw bytes to a branded ResourceSignature, returning undefined for empty/missing input. */
+export function toResourceSignature(raw?: Uint8Array): ResourceSignature {
+  return raw && raw.length > 0
+    ? (raw as ResourceSignature)
+    : (new Uint8Array(0) as ResourceSignature);
+}
+
+/** Decode base64url-encoded string back to a branded ResourceSignature. */
+export function base64UrlToSignature(str: string): ResourceSignature {
+  return toResourceSignature(Buffer.from(str, "base64url"))!;
+}
+
+/** Converts bigint global resource id and signature to a SignedResourceId string.
+ *  Format: "<globalIdString>|<signatureHex>" */
+export function createSignedResourceId(
+  globalId: bigint,
+  signature?: ResourceSignature,
+): SignedResourceId {
+  if (isLocalResourceId(globalId))
+    throw new Error(`Local resource id: ${resourceIdToString(globalId)}`);
+  if (isNullResourceId(globalId)) throw new Error(`Null resource id.`);
+
+  const sigHex = signature ? Buffer.from(signature).toString("hex") : "";
+  return `${String(globalId)}|${sigHex}` as SignedResourceId; // lint-allow-cast
+}
+
+export function parseSignedResourceId(resourceId: SignedResourceId): {
+  globalId: GlobalResourceId;
+  signature: ResourceSignature;
+} {
+  if (typeof resourceId !== "string") {
+    throw new Error(`Not a signed resource id: ${resourceId}`);
+  }
+
+  const pipeIdx = resourceId.indexOf("|");
+  if (pipeIdx < 0) throw new Error(`Malformed signed resource id (no '|'): ${resourceId}`);
+
+  const globalIdStr = resourceId.substring(0, pipeIdx);
+  const signatureHex = resourceId.substring(pipeIdx + 1);
+
+  const globalId = BigInt(globalIdStr);
+  if (isNullSignedResourceId(globalId) || isLocalResourceId(globalId))
+    throw new Error(`Invalid global id portion in signed resource id: ${globalIdStr}`);
+
+  const signature: ResourceSignature = (
+    signatureHex.length > 0 ? Buffer.from(signatureHex, "hex") : new Uint8Array(0)
+  ) as ResourceSignature;
+
+  return { globalId: globalId as GlobalResourceId, signature };
 }

package/src/core/user_resources.ts

@@ -0,0 +1,332 @@
+import { createHash } from "node:crypto";
+import type { LLPlClient } from "./ll_client";
+import type { PlTransaction } from "./transaction";
+import { toGlobalResourceId } from "./transaction";
+import type { OptionalSignedResourceId, SignedResourceId, ResourceType } from "./types";
+import {
+  createSignedResourceId,
+  isNotNullSignedResourceId,
+  NullSignedResourceId,
+  toResourceSignature,
+} from "./types";
+import { isUnimplementedError } from "./errors";
+import { ClientRoot } from "../helpers/pl";
+
+const AnonymousClientRoot = "AnonymousRoot";
+const LsStorageTypePrefix = "LS/"; // implements ls API in particular storage
+const LsProviderFieldPrefix = "storage/"; // provides access to storages list
+
+/** Information about a single data library (LS storage). */
+export interface StorageInfo {
+  /** Machine-stable identifier, e.g. "library". Used for filtering and map keys. */
+  readonly storageId: string;
+  /** Human-readable display name. For V1/legacy equals storageId; for V2 from resource JSON data. */
+  readonly storageName: string;
+  /** Signed resource ID for this storage resource. */
+  readonly resourceId: SignedResourceId;
+  /** Full resource type including correct version ("1" or "2"). */
+  readonly resourceType: ResourceType;
+}
+
+/** V2 LsStorage resource JSON data shape (contract with backend). */
+interface LsStorageV2Data {
+  storageName: string;
+  storageID: string;
+}
+
+/**
+ * Callback type for running transactions. Matches PlClient._withTx signature
+ * so the index can run transactions before PlClient is fully initialized.
+ */
+export type TxRunner = <T>(
+  name: string,
+  writable: boolean,
+  clientRoot: OptionalSignedResourceId,
+  body: (tx: PlTransaction) => Promise<T>,
+) => Promise<T>;
+
+type BackendCapability = "getUserRoot" | "listUserResources" | "legacy";
+
+/**
+ * Abstracts user resource discovery with backward compatibility.
+ *
+ * Detects backend capability on the first getUserRoot() call and remembers
+ * the result. Three-tier fallback:
+ * 1. getUserRoot RPC (newest, supports doNotCreate)
+ * 2. listUserResources RPC (streams all resources, picks userRoot)
+ * 3. Named resource lookup/creation via transaction (legacy)
+ */
+export class UserResources {
+  private backendCapability: BackendCapability | undefined;
+
+  constructor(
+    private readonly ll: LLPlClient,
+    private readonly runTx: TxRunner,
+    public readonly authUser: string | null,
+  ) {}
+
+  /**
+   * Returns the user's root resource ID.
+   *
+   * On first call, detects backend capability by trying methods in order:
+   * 1. getUserRoot RPC (newest)
+   * 2. listUserResources RPC
+   * 3. Named resource lookup/creation via transaction (legacy)
+   */
+  async getUserRoot(): Promise<SignedResourceId>;
+  async getUserRoot(opts: { login?: string }): Promise<SignedResourceId>;
+  async getUserRoot(opts: { login?: string; doNotCreate: false }): Promise<SignedResourceId>;
+  async getUserRoot(opts: {
+    login?: string;
+    doNotCreate: true;
+  }): Promise<SignedResourceId | undefined>;
+  async getUserRoot(
+    opts: { login?: string; doNotCreate?: boolean } = {},
+  ): Promise<SignedResourceId | undefined> {
+    if (this.backendCapability === undefined) {
+      return await this.detectAndGetUserRoot(opts);
+    }
+    return await this.getUserRootWith(this.backendCapability, opts);
+  }
+
+  private async detectAndGetUserRoot(
+    opts: { login?: string; doNotCreate?: boolean } = {},
+  ): Promise<SignedResourceId | undefined> {
+    // 1. Try getUserRoot RPC
+    try {
+      const root = await this.getUserRootViaRpc(opts);
+      this.backendCapability = "getUserRoot";
+      return root;
+    } catch (err) {
+      if (!isUnimplementedError(err)) throw err;
+    }
+
+    // 2. Try listUserResources
+    try {
+      const root = await this.getUserRootViaList(opts);
+      this.backendCapability = "listUserResources";
+      return root;
+    } catch (err) {
+      if (!isUnimplementedError(err)) throw err;
+    }
+
+    // 3. Legacy fallback
+    this.backendCapability = "legacy";
+    return await this.getUserRootViaLegacy(opts);
+  }
+
+  private async getUserRootWith(
+    capability: BackendCapability,
+    opts: { login?: string; doNotCreate?: boolean } = {},
+  ): Promise<SignedResourceId | undefined> {
+    switch (capability) {
+      case "getUserRoot":
+        return await this.getUserRootViaRpc(opts);
+      case "listUserResources":
+        return await this.getUserRootViaList(opts);
+      case "legacy":
+        return await this.getUserRootViaLegacy(opts);
+    }
+  }
+
+  /**
+   * Returns all data libraries the user has access to.
+   * Always fetches fresh from the server (no caching).
+   */
+  async getDataLibraries(
+    opts: { login?: string; doNotCreateUserRoot?: boolean } = {},
+  ): Promise<ReadonlyMap<string, StorageInfo>> {
+    if (this.backendCapability === undefined) {
+      // First call — detect backend capability
+      try {
+        const libs = await this.getDataLibrariesViaList(opts);
+        // getUserRoot RPC doesn't return libraries, but listUserResources does;
+        // record at least "listUserResources" so future getUserRoot calls don't re-detect.
+        this.backendCapability = "listUserResources";
+        return libs;
+      } catch (err) {
+        if (!isUnimplementedError(err)) throw err;
+        this.backendCapability = "legacy";
+        return await this.getDataLibrariesViaLegacy();
+      }
+    }
+
+    // A server that supports getUserRoot definitely supports listUserResources.
+    if (this.backendCapability !== "legacy") {
+      return await this.getDataLibrariesViaList(opts);
+    }
+    return await this.getDataLibrariesViaLegacy();
+  }
+
+  private async getUserRootViaRpc(opts: { login?: string }): Promise<SignedResourceId>;
+  private async getUserRootViaRpc(opts: {
+    login?: string;
+    doNotCreate: false;
+  }): Promise<SignedResourceId>;
+  private async getUserRootViaRpc(opts: {
+    login?: string;
+    doNotCreate: true;
+  }): Promise<SignedResourceId | undefined>;
+  private async getUserRootViaRpc(
+    opts: { login?: string; doNotCreate?: boolean } = {},
+  ): Promise<SignedResourceId | undefined> {
+    const resp = await this.ll.getUserRoot({
+      login: opts.login,
+      doNotCreate: opts.doNotCreate,
+    });
+    if (resp.userRoot === undefined) {
+      if (opts.doNotCreate) return undefined;
+      throw new Error("getUserRoot returned no userRoot entry");
+    }
+    return createSignedResourceId(
+      resp.userRoot.resourceId,
+      toResourceSignature(resp.userRoot.resourceSignature),
+    );
+  }
+
+  private async getUserRootViaList(opts: { login?: string }): Promise<SignedResourceId>;
+  private async getUserRootViaList(opts: {
+    login?: string;
+    doNotCreate: false;
+  }): Promise<SignedResourceId>;
+  private async getUserRootViaList(opts: {
+    login?: string;
+    doNotCreate: true;
+  }): Promise<SignedResourceId | undefined>;
+  private async getUserRootViaList(
+    opts: { login?: string; doNotCreate?: boolean } = {},
+  ): Promise<SignedResourceId | undefined> {
+    const responses = await this.ll.listUserResources({ login: opts.login, limit: 1 });
+    for (const msg of responses) {
+      if (msg.entry.oneofKind === "userRoot") {
+        return createSignedResourceId(
+          msg.entry.userRoot.resourceId,
+          toResourceSignature(msg.entry.userRoot.resourceSignature),
+        );
+      }
+    }
+    throw new Error("listUserResources returned no userRoot entry");
+  }
+
+  private async getDataLibrariesViaList(
+    opts: { login?: string } = {},
+  ): Promise<ReadonlyMap<string, StorageInfo>> {
+    const responses = await this.ll.listUserResources({ login: opts.login });
+
+    // Collect all LS/* shared resources, separating V1 and V2
+    const v1Entries: StorageInfo[] = [];
+    const v2ResourceIds: { resourceId: SignedResourceId; resourceType: ResourceType }[] = [];
+
+    for (const msg of responses) {
+      if (msg.entry.oneofKind !== "sharedResource") continue;
+      const sr = msg.entry.sharedResource;
+
+      if (!sr.resourceType) continue;
+      const typeName = sr.resourceType.name;
+      const typeVersion = sr.resourceType.version;
+      if (!typeName.startsWith(LsStorageTypePrefix)) continue;
+
+      const rId = createSignedResourceId(sr.resourceId, toResourceSignature(sr.resourceSignature));
+      const rType: ResourceType = { name: typeName, version: typeVersion };
+
+      if (typeVersion === "2") {
+        v2ResourceIds.push({ resourceId: rId, resourceType: rType });
+      } else {
+        // V1 or unknown version: derive storageId from type name
+        const storageId = typeName.substring(LsStorageTypePrefix.length);
+        v1Entries.push({
+          storageId,
+          storageName: storageId,
+          resourceId: rId,
+          resourceType: rType,
+        });
+      }
+    }
+
+    // Read V2 resource data in a single transaction
+    let v2Entries: StorageInfo[] = [];
+    if (v2ResourceIds.length > 0) {
+      v2Entries = await this.runTx(
+        "ReadLsStorageV2Data",
+        false,
+        NullSignedResourceId,
+        async (tx) => {
+          const entries: StorageInfo[] = [];
+          for (const { resourceId, resourceType } of v2ResourceIds) {
+            const rd = await tx.getResourceData(resourceId, false);
+            if (rd.data) {
+              const v2Data = JSON.parse(Buffer.from(rd.data).toString("utf-8")) as LsStorageV2Data;
+              entries.push({
+                storageId: v2Data.storageID,
+                storageName: v2Data.storageName,
+                resourceId,
+                resourceType,
+              });
+            }
+          }
+          return entries;
+        },
+      );
+    }
+
+    const result = new Map<string, StorageInfo>();
+    for (const entry of [...v1Entries, ...v2Entries]) {
+      result.set(entry.storageId, entry);
+    }
+    return result;
+  }
+
+  private async getUserRootViaLegacy(opts: { login?: string }): Promise<SignedResourceId>;
+  private async getUserRootViaLegacy(opts: {
+    login?: string;
+    doNotCreateUserRoot: false;
+  }): Promise<SignedResourceId>;
+  private async getUserRootViaLegacy(opts: {
+    login?: string;
+    doNotCreateUserRoot: true;
+  }): Promise<SignedResourceId | undefined>;
+  private async getUserRootViaLegacy(
+    opts: { login?: string; doNotCreateUserRoot?: boolean } = {},
+  ): Promise<SignedResourceId | undefined> {
+    const login = opts.login ?? this.authUser;
+    const mainRootName =
+      login === null ? AnonymousClientRoot : createHash("sha256").update(login).digest("hex");
+
+    return await this.runTx("initialization", true, NullSignedResourceId, async (tx) => {
+      if (await tx.checkResourceNameExists(mainRootName)) {
+        return await tx.getResourceByName(mainRootName);
+      }
+
+      if (opts.doNotCreateUserRoot) {
+        return undefined;
+      }
+
+      const mainRoot = tx.createRoot(ClientRoot);
+      tx.setResourceName(mainRootName, mainRoot);
+      await tx.commit();
+      return await toGlobalResourceId(mainRoot);
+    });
+  }
+
+  private async getDataLibrariesViaLegacy(): Promise<ReadonlyMap<string, StorageInfo>> {
+    return await this.runTx("GetAvailableStorageIds", false, NullSignedResourceId, async (tx) => {
+      const lsProviderId = await tx.getResourceByName("LSProvider");
+      const provider = await tx.getResourceData(lsProviderId, true);
+
+      const result = new Map<string, StorageInfo>();
+      for (const field of provider.fields) {
+        if (field.type !== "Dynamic" || !isNotNullSignedResourceId(field.value)) continue;
+        if (!field.name.startsWith(LsProviderFieldPrefix)) continue;
+
+        const storageId = field.name.substring(LsProviderFieldPrefix.length);
+        result.set(storageId, {
+          storageId,
+          storageName: storageId,
+          resourceId: field.value,
+          resourceType: { name: `${LsStorageTypePrefix}${storageId}`, version: "1" },
+        });
+      }
+      return result;
+    });
+  }
+}

package/src/helpers/poll.ts

@@ -1,8 +1,12 @@
 import type { PlClient } from "../core/client";
 import type { RetryOptions } from "@milaboratories/ts-helpers";
 import { createRetryState, nextRetryStateOrError, notEmpty } from "@milaboratories/ts-helpers";
-import type { FieldData, FieldType, ResourceData, ResourceId } from "../core/types";
-import { isNotNullResourceId, isNullResourceId, resourceIdToString } from "../core/types";
+import type { FieldData, FieldType, ResourceData, SignedResourceId } from "../core/types";
+import {
+  isNotNullSignedResourceId,
+  isNullSignedResourceId,
+  resourceIdToString,
+} from "../core/types";
 import type { PlTransaction } from "../core/transaction";
 import * as tp from "node:timers/promises";
 
@@ -38,7 +42,7 @@ export class PollResourceAccessor {
   }
 
   public async requireNoError(): Promise<PollResourceAccessor> {
-    if (isNullResourceId(this.data.error)) return this;
+    if (isNullSignedResourceId(this.data.error)) return this;
     await this.tx.throwError(this.data.error, this.path);
     // hmm... https://github.com/microsoft/TypeScript/issues/34955
     return this;
@@ -73,10 +77,13 @@ export class PollResourceAccessor {
     const path = [...this.path, name];
 
     const fieldData = this.getFieldData(name, expectedType);
-    if (isNotNullResourceId(fieldData.error) && (failOnError || isNullResourceId(fieldData.value)))
+    if (
+      isNotNullSignedResourceId(fieldData.error) &&
+      (failOnError || isNullSignedResourceId(fieldData.value))
+    )
       await this.tx.throwError(fieldData.error, path);
 
-    if (isNullResourceId(fieldData.value)) throw new ContinuePolling();
+    if (isNullSignedResourceId(fieldData.value)) throw new ContinuePolling();
 
     return await this.tx.get(fieldData.value, failOnError, path);
   }
@@ -103,7 +110,7 @@ export class PollResourceAccessor {
     return await this.getMultiObj(
       ops,
       ...this.data.fields
-        .filter((f) => f.valueIsFinal || isNotNullResourceId(f.error))
+        .filter((f) => f.valueIsFinal || isNotNullSignedResourceId(f.error))
         .map((f) => f.name),
     );
   }
@@ -123,7 +130,7 @@ export class PollTxAccessor {
   constructor(public readonly tx: PlTransaction) {}
 
   public async get(
-    rid: ResourceId,
+    rid: SignedResourceId,
     failOnError: boolean = true,
     path: string[] = [],
   ): Promise<PollResourceAccessor> {
@@ -133,7 +140,7 @@ export class PollTxAccessor {
     return accessor;
   }
 
-  async throwError(error: ResourceId, path: string[] = []): Promise<never> {
+  async throwError(error: SignedResourceId, path: string[] = []): Promise<never> {
     const errorRes = await this.get(error);
     const errorText = Buffer.from(notEmpty(errorRes.data.data)).toString();
     throw new Error(`${path.join(" -> ")} = ${errorText}`);

package/src/helpers/state_helpers.ts

@@ -1,6 +1,6 @@
 import type { FieldData } from "../core/types";
-import { isNotNullResourceId } from "../core/types";
+import { isNotNullSignedResourceId } from "../core/types";
 
 export function fieldResolved(data: Pick<FieldData, "value" | "error">) {
-  return isNotNullResourceId(data.error) || isNotNullResourceId(data.value);
+  return isNotNullSignedResourceId(data.error) || isNotNullSignedResourceId(data.value);
 }