transactionDataFromV1 function

dynamic transactionDataFromV1(dynamic data)

Implementation

dynamic transactionDataFromV1(dynamic data) {
  dynamic expiration;
  if (data["expiration"] != null) {
    if (data["expiration"]["Epoch"] != null) {
      expiration = {"Epoch": data["expiration"]["Epoch"]};
    } else {
      expiration = {"None": true};
    }
  }

  return {
    "version": 2,
    "sender": data["sender"],
    "expiration": expiration,
    "gasData": {
      "owner": data["gasConfig"]?["owner"],
      "budget": data["gasConfig"]?["budget"]?.toString(),
      "price": data["gasConfig"]?["price"]?.toString(),
      "payment": data["gasConfig"]?["payment"]?.map(
        (ref) => ({
          "digest": ref["digest"],
          "objectId": ref["objectId"],
          "version": ref["version"]?.toString(),
        }),
      ),
    },
    "inputs": data["inputs"]?.map((input) {
      if (input["kind"] == 'Input') {
        if (input["value"] is Map &&
            (input["value"]["Object"] != null ||
                input["value"]["Pure"] != null)) {
          final value = input["value"];

          if (value["Object"] != null) {
            if (value["Object"]["ImmOrOwned"] != null) {
              return {
                "Object": {
                  "ImmOrOwnedObject": {
                    "objectId": value["Object"]["ImmOrOwned"]["objectId"],
                    "version": value["Object"]["ImmOrOwned"]["version"]
                        ?.toString(),
                    "digest": value["Object"]["ImmOrOwned"]["digest"],
                  },
                },
              };
            }
            if (value["Object"]["Shared"] != null) {
              return {
                "Object": {
                  "SharedObject": {
                    "mutable": value["Object"]["Shared"]["mutable"],
                    "initialSharedVersion":
                        value["Object"]["Shared"]["initialSharedVersion"],
                    "objectId": value["Object"]["Shared"]["objectId"],
                  },
                },
              };
            }
            if (value["Object"]["Receiving"] != null) {
              return {
                "Object": {
                  "Receiving": {
                    "digest": value["Object"]["Receiving"]["digest"],
                    "version": value["Object"]["Receiving"]["version"]
                        ?.toString(),
                    "objectId": value["Object"]["Receiving"]["objectId"],
                  },
                },
              };
            }

            throw ArgumentError('Invalid object input');
          }

          return {
            "Pure": {
              "bytes": toB64(Uint8List.fromList(value["Pure"].cast<int>())),
            },
          };
        }

        if (input["type"] == 'object') {
          return {
            "UnresolvedObject": {"objectId": input["value"]?.toString()},
          };
        }

        return {
          "UnresolvedPure": {"value": input["value"]},
        };
      }

      throw ArgumentError('Invalid input');
    }),
    "commands": data["transactions"]?.map((transaction) {
      switch (transaction["kind"]) {
        case 'MakeMoveVec':
          return {
            "MakeMoveVec": {
              "type": transaction["type"]?["Some"] != null
                  ? TypeTagSerializer.tagToString(transaction["type"]["Some"])
                  : null,
              "elements": transaction["objects"]?.map(
                (arg) => parseV1TransactionArgument(arg),
              ),
            },
          };
        case 'MergeCoins':
          {
            return {
              "MergeCoins": {
                "destination": parseV1TransactionArgument(
                  transaction["destination"],
                ),
                "sources": transaction["sources"]?.map(
                  (arg) => parseV1TransactionArgument(arg),
                ),
              },
            };
          }
        case 'MoveCall':
          {
            final [pkg, mod, fn] = transaction["target"].split('::');
            return {
              "MoveCall": {
                "package": pkg,
                "module": mod,
                "function": fn,
                "typeArguments": transaction["typeArguments"],
                "arguments": transaction["arguments"]?.map(
                  (arg) => parseV1TransactionArgument(arg),
                ),
              },
            };
          }
        case 'Publish':
          {
            return {
              "Publish": {
                "modules": transaction["modules"]?.map((mod) => toB64(mod)),
                "dependencies": transaction["dependencies"],
              },
            };
          }
        case 'SplitCoins':
          {
            return {
              "SplitCoins": {
                "coin": parseV1TransactionArgument(transaction["coin"]),
                "amounts": transaction["amounts"]?.map(
                  (arg) => parseV1TransactionArgument(arg),
                ),
              },
            };
          }
        case 'TransferObjects':
          {
            return {
              "TransferObjects": {
                "objects": transaction["objects"]?.map(
                  (arg) => parseV1TransactionArgument(arg),
                ),
                "address": parseV1TransactionArgument(transaction["address"]),
              },
            };
          }
        case 'Upgrade':
          {
            return {
              "Upgrade": {
                "modules": transaction["modules"]?.map((mod) => toB64(mod)),
                "dependencies": transaction["dependencies"],
                "package": transaction["packageId"],
                "ticket": parseV1TransactionArgument(transaction["ticket"]),
              },
            };
          }
      }

      throw Exception("Unknown transaction $transaction");
    }).toList(),
  };
}