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"],
          ),
        );
  }
}