resolveObjectReferences method

Future<void> resolveObjectReferences(BuildOptions options)

Implementation

Future<void> resolveObjectReferences(BuildOptions options) async {
  // Keep track of the object references that will need to be resolved at the end of the transaction.
  // We keep the input by-reference to avoid needing to re-resolve it:
  final objectsToResolve = _blockData.inputs.where((input) {
    return (
      input["UnresolvedObject"] != null &&
      (input["UnresolvedObject"]["version"] == null && input["UnresolvedObject"]["initialSharedVersion"] == null)
    );
  });

  final dedupedIds = Set.from(
      objectsToResolve.map((input) => normalizeSuiObjectId(input["UnresolvedObject"]["objectId"]))
    ).toList();

  final objectChunks = dedupedIds.isNotEmpty ? chunk(dedupedIds, MAX_OBJECTS_PER_FETCH) : [];

  final resolved = <SuiObjectResponse>[];
  final objectsResult = (
    await Future.wait(
      objectChunks.map((chunk) =>
        expectClient(options).multiGetObjects(
          chunk.cast<String>(),
          options: SuiObjectDataOptions(showOwner: true)
        ),
      ),
    )
  );
  for (var item in objectsResult) {
    resolved.addAll(item);
  }

  final responsesById = Map.fromIterables(
    dedupedIds,
    dedupedIds.asMap().map((index, id) => MapEntry(index, resolved[index])).values,
  );

  final invalidObjects = responsesById.entries
    .where((entry) => entry.value.error != null)
    .map((entry) => entry.value.error?.toJson())
    .toList();

  if (invalidObjects.isNotEmpty) {
    throw ArgumentError("The following input objects are invalid: ${invalidObjects.join(', ')}");
  }

  final objects = resolved.map((object) {
    if (object.error != null || object.data == null) {
      throw ArgumentError("Failed to fetch object: ${object.error}");
    }
    final owner = object.data?.owner;
    final initialSharedVersion = owner?.shared?.initialSharedVersion;

    return {
      "objectId": object.data?.objectId,
      "digest": object.data?.digest,
      "version": object.data?.version,
      "initialSharedVersion": initialSharedVersion
    };
  }).toList();

  final objectsById = Map.fromIterables(
    dedupedIds,
    dedupedIds.asMap().map((index, id) => MapEntry(index, objects[index])).values,
  );

  for (int index = 0; index < _blockData.inputs.length; index++) {
    final input = _blockData.inputs[index];
    if (input["UnresolvedObject"] == null) {
      continue;
    }

    CallArg updated;
    final id = normalizeSuiAddress(input["UnresolvedObject"]["objectId"]);
    final object = objectsById[id];

    if ((input["UnresolvedObject"]?["initialSharedVersion"] ?? object?["initialSharedVersion"]) != null) {
      updated = Inputs.sharedObjectRef({
        "objectId": id,
        "initialSharedVersion":
          input["UnresolvedObject"]["initialSharedVersion"] ?? object?["initialSharedVersion"],
        "mutable": isUsedAsMutable(_blockData, index),
      });
    } else if (isUsedAsReceiving(_blockData, index)) {
      updated = Inputs.receivingRef(
        SuiObjectRef(
          input["UnresolvedObject"]["digest"] ?? object?["digest"],
          id,
          input["UnresolvedObject"]["version"] ?? object?["version"],
        )
      );
    }

    _blockData.inputs[_blockData.inputs.indexOf(input)] =
      updated ??
      Inputs.objectRef(
        SuiObjectRef(
          input["UnresolvedObject"]["digest"] ?? object?["digest"],
          id,
          input["UnresolvedObject"]["version"] ?? object?["version"],
        )
      );
  }
}