@iota/graphql-transport 0.1.1 → 0.2.0

package/dist/cjs/mappers/transaction-block.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var transaction_block_exports = {};
 __export(transaction_block_exports, {
+  mapEffects: () => mapEffects,
   mapGraphQLTransactionBlockToRpcTransactionBlock: () => mapGraphQLTransactionBlockToRpcTransactionBlock,
   mapProgramableTransaction: () => mapProgramableTransaction,
   mapTransactionBlockToInput: () => mapTransactionBlockToInput
@@ -25,22 +26,10 @@ __export(transaction_block_exports, {
 module.exports = __toCommonJS(transaction_block_exports);
 var import_bcs = require("@iota/bcs");
 var import_bcs2 = require("@iota/iota-sdk/bcs");
-var import_owner = require("./owner.js");
+var import_utils = require("@iota/iota-sdk/utils");
 var import_util = require("./util.js");
 function mapGraphQLTransactionBlockToRpcTransactionBlock(transactionBlock, options, errors) {
-  const deletedChanges = transactionBlock.effects?.objectChanges?.nodes?.filter((change) => change?.idDeleted === true).map((change) => ({
-    digest: change?.inputState?.digest,
-    version: String(change?.inputState?.version),
-    objectId: change?.inputState?.address
-  }));
-  const createdChanges = transactionBlock.effects?.objectChanges?.nodes?.filter((change) => change?.idCreated === true).map((change) => ({
-    owner: (0, import_owner.mapGraphQLOwnerToRpcOwner)(change?.outputState?.owner),
-    reference: {
-      digest: change?.outputState?.digest,
-      version: change?.outputState?.version,
-      objectId: change?.outputState?.address
-    }
-  }));
+  const effects = transactionBlock.effects?.bcs ? mapEffects(transactionBlock.effects.bcs) : null;
   return {
     balanceChanges: transactionBlock.effects?.balanceChanges?.nodes.map((balanceChange) => ({
       amount: balanceChange?.amount,
@@ -54,53 +43,12 @@ function mapGraphQLTransactionBlockToRpcTransactionBlock(transactionBlock, optio
     ...typeof transactionBlock.effects?.checkpoint?.sequenceNumber === "number" ? { checkpoint: transactionBlock.effects.checkpoint.sequenceNumber.toString() } : {},
     ...transactionBlock.effects?.timestamp ? { timestampMs: new Date(transactionBlock.effects?.timestamp).getTime().toString() } : {},
     digest: transactionBlock.digest,
-    effects: options?.showEffects ? {
-      ...createdChanges?.length ? { created: createdChanges } : {},
-      ...deletedChanges?.length ? { deleted: deletedChanges } : {},
-      dependencies: transactionBlock.effects?.dependencies?.nodes.map(
-        (dep) => dep?.digest
-      ),
-      executedEpoch: String(transactionBlock.effects?.executedEpoch?.epochId),
-      gasObject: {
-        owner: (0, import_owner.mapGraphQLOwnerToRpcOwner)(
-          transactionBlock.effects?.gasEffects?.gasObject?.owner
-        ),
-        reference: {
-          digest: transactionBlock.effects?.gasEffects?.gasObject?.digest,
-          version: transactionBlock.effects?.gasEffects?.gasObject?.version,
-          objectId: transactionBlock.effects?.gasEffects?.gasObject?.address
-        }
-      },
-      gasUsed: {
-        computationCost: transactionBlock.effects?.gasEffects?.gasSummary?.computationCost,
-        nonRefundableStorageFee: transactionBlock.effects?.gasEffects?.gasSummary?.nonRefundableStorageFee,
-        storageCost: transactionBlock.effects?.gasEffects?.gasSummary?.storageCost,
-        storageRebate: transactionBlock.effects?.gasEffects?.gasSummary?.storageRebate
-      },
-      messageVersion: "v1",
-      modifiedAtVersions: transactionBlock.effects?.objectChanges?.nodes?.filter((change) => !change?.idCreated && !change?.idDeleted)?.map((change) => ({
-        objectId: change?.inputState?.address,
-        sequenceNumber: String(change?.inputState?.version)
-      })),
-      mutated: transactionBlock.effects?.objectChanges?.nodes?.filter((change) => !change?.idCreated && !change?.idDeleted)?.map((change) => ({
-        owner: (0, import_owner.mapGraphQLOwnerToRpcOwner)(change?.outputState?.owner),
-        reference: {
-          digest: change?.outputState?.digest,
-          version: change?.outputState?.version,
-          objectId: change?.outputState?.address
-        }
-      })),
-      status: {
-        status: transactionBlock.effects?.status?.toLowerCase()
-      },
-      transactionDigest: transactionBlock.digest
-      // sharedObjects: [], // TODO
-      // unwrapped: [], // TODO
-      // unwrappedThenDeleted: [], // TODO
-      // wrapped: [], // TODO
-    } : void 0,
+    ...options?.showRawEffects ? {
+      rawEffects: transactionBlock.effects?.bcs ? Array.from((0, import_bcs.fromB64)(transactionBlock.effects?.bcs)) : void 0
+    } : {},
+    effects: options?.showEffects ? effects : void 0,
     ...errors ? { errors } : {},
-    events: options?.showEvents ? transactionBlock.effects?.events?.nodes.map((event) => ({
+    events: transactionBlock.effects?.events?.nodes.map((event) => ({
       bcs: event.bcs,
       id: {
         eventSeq: "",
@@ -114,45 +62,92 @@ function mapGraphQLTransactionBlockToRpcTransactionBlock(transactionBlock, optio
       timestampMs: new Date(event.timestamp).getTime().toString(),
       transactionModule: `${event.sendingModule?.package.address}::${event.sendingModule?.name}`,
       type: (0, import_util.toShortTypeString)(event.type?.repr)
-    })) ?? [] : void 0,
+    })) ?? [],
     rawTransaction: options?.showRawInput ? transactionBlock.rawTransaction : void 0,
     ...options?.showInput ? {
       transaction: transactionBlock.rawTransaction && mapTransactionBlockToInput(
         import_bcs2.bcs.SenderSignedData.parse((0, import_bcs.fromB64)(transactionBlock.rawTransaction))[0]
       )
     } : {},
-    objectChanges: options?.showObjectChanges ? transactionBlock.effects?.objectChanges?.nodes?.map(
-      (change) => change?.idDeleted ? {
-        digest: change?.inputState?.digest,
-        objectId: change?.inputState?.address,
-        owner: (0, import_owner.mapGraphQLOwnerToRpcOwner)(change.inputState?.owner),
-        objectType: (0, import_util.toShortTypeString)(
-          change?.inputState?.asMoveObject?.contents?.type.repr
-        ),
-        sender: transactionBlock.sender?.address,
-        type: "deleted",
-        version: change?.inputState?.version.toString()
-      } : {
-        digest: change?.outputState?.digest,
-        objectId: change?.outputState?.address,
-        owner: (0, import_owner.mapGraphQLOwnerToRpcOwner)(change.outputState?.owner),
+    objectChanges: options?.showObjectChanges ? mapObjectChanges(transactionBlock, effects) : void 0
+  };
+}
+function mapObjectChanges(transactionBlock, effects) {
+  const changes = [];
+  effects?.mutated?.forEach((mutated) => {
+    const objectChange = transactionBlock.effects?.objectChanges?.nodes.find(
+      (change) => change.address === mutated.reference.objectId
+    );
+    changes.push({
+      type: "mutated",
+      digest: mutated.reference.digest,
+      previousVersion: String(objectChange?.inputState?.version),
+      objectId: mutated.reference.objectId,
+      owner: mutated.owner,
+      objectType: (0, import_util.toShortTypeString)(
+        objectChange?.outputState?.asMoveObject?.contents?.type.repr
+      ),
+      sender: transactionBlock.sender?.address,
+      version: mutated.reference.version?.toString()
+    });
+  });
+  effects?.created?.forEach((created) => {
+    const objectChange = transactionBlock.effects?.objectChanges?.nodes.find(
+      (change) => change.address === created.reference.objectId
+    );
+    if (objectChange?.outputState?.asMovePackage) {
+      changes.push({
+        type: "published",
+        digest: created.reference.digest,
+        version: created.reference.version?.toString(),
+        packageId: objectChange.address,
+        modules: objectChange.outputState.asMovePackage.modules?.nodes.map(
+          (module2) => module2.name
+        )
+      });
+    } else {
+      changes.push({
+        type: "created",
+        digest: created.reference.digest,
+        objectId: created.reference.objectId,
+        owner: created.owner,
         objectType: (0, import_util.toShortTypeString)(
-          change?.outputState?.asMoveObject?.contents?.type.repr
+          transactionBlock.effects?.objectChanges?.nodes.find(
+            (change) => change.address === created.reference.objectId
+          )?.outputState?.asMoveObject?.contents?.type.repr
         ),
-        ...typeof change?.inputState?.version === "number" ? { previousVersion: change?.inputState?.version.toString() } : {},
         sender: transactionBlock.sender?.address,
-        type: change?.idCreated ? "created" : "mutated",
-        version: change?.outputState?.version.toString()
-      }
-    ).sort((a, b) => {
-      if (a.type === "created" && b.type === "deleted") {
-        return -1;
-      } else if (a.type === "deleted" && b.type === "created") {
-        return 1;
-      }
-      return 0;
-    }) : void 0
-  };
+        version: created.reference.version?.toString()
+      });
+    }
+  });
+  effects?.deleted?.forEach((deleted) => {
+    changes.push({
+      type: "deleted",
+      objectId: deleted.objectId,
+      objectType: (0, import_util.toShortTypeString)(
+        transactionBlock.effects?.objectChanges?.nodes.find(
+          (change) => change.address === deleted.objectId
+        )?.inputState?.asMoveObject?.contents?.type.repr
+      ),
+      sender: transactionBlock.sender?.address,
+      version: deleted.version?.toString()
+    });
+  });
+  effects?.unwrapped?.forEach((unwrapped) => {
+    changes.push({
+      type: "wrapped",
+      objectId: unwrapped.reference.objectId,
+      objectType: (0, import_util.toShortTypeString)(
+        transactionBlock.effects?.objectChanges?.nodes.find(
+          (change) => change.address === unwrapped.reference.objectId
+        )?.outputState?.asMoveObject?.contents?.type.repr
+      ),
+      sender: transactionBlock.sender?.address,
+      version: unwrapped.reference.version?.toString()
+    });
+  });
+  return changes;
 }
 function mapTransactionBlockToInput(data) {
   const txData = data.intentMessage.value.V1;
@@ -183,105 +178,101 @@ function mapProgramableTransaction(programableTransaction) {
   return {
     inputs: programableTransaction.inputs.map(mapTransactionInput),
     kind: "ProgrammableTransaction",
-    transactions: programableTransaction.transactions.map(mapTransaction)
+    transactions: programableTransaction.commands.map(mapTransaction)
   };
 }
 function mapTransactionInput(input) {
-  if ("Pure" in input) {
+  if (input.Pure) {
     return {
       type: "pure",
-      value: Uint8Array.from(input.Pure)
+      value: (0, import_bcs.fromB64)(input.Pure.bytes)
     };
   }
-  if ("Object" in input) {
-    if ("ImmOrOwned" in input.Object) {
-      return {
-        type: "object",
-        digest: input.Object.ImmOrOwned.digest,
-        version: input.Object.ImmOrOwned.version,
-        objectId: input.Object.ImmOrOwned.objectId,
-        objectType: "immOrOwnedObject"
-      };
-    }
-    if ("Shared" in input.Object) {
-      return {
-        type: "object",
-        initialSharedVersion: input.Object.Shared.initialSharedVersion,
-        objectId: input.Object.Shared.objectId,
-        mutable: input.Object.Shared.mutable,
-        objectType: "sharedObject"
-      };
-    }
-    if ("Receiving" in input.Object) {
-      return {
-        type: "object",
-        digest: input.Object.Receiving.digest,
-        version: input.Object.Receiving.version,
-        objectId: input.Object.Receiving.objectId,
-        objectType: "receiving"
-      };
-    }
-    throw new Error(`Unknown object type: ${input.Object}`);
+  if (input.Object.ImmOrOwnedObject) {
+    return {
+      type: "object",
+      digest: input.Object.ImmOrOwnedObject.digest,
+      version: input.Object.ImmOrOwnedObject.version,
+      objectId: input.Object.ImmOrOwnedObject.objectId,
+      objectType: "immOrOwnedObject"
+    };
+  }
+  if (input.Object.SharedObject) {
+    return {
+      type: "object",
+      initialSharedVersion: input.Object.SharedObject.initialSharedVersion,
+      objectId: input.Object.SharedObject.objectId,
+      mutable: input.Object.SharedObject.mutable,
+      objectType: "sharedObject"
+    };
+  }
+  if (input.Object.Receiving) {
+    return {
+      type: "object",
+      digest: input.Object.Receiving.digest,
+      version: input.Object.Receiving.version,
+      objectId: input.Object.Receiving.objectId,
+      objectType: "receiving"
+    };
   }
-  throw new Error(`Unknown input type ${input}`);
+  throw new Error(`Unknown object type: ${input.Object}`);
 }
 function mapTransaction(transaction) {
-  switch (transaction.kind) {
+  switch (transaction.$kind) {
     case "MoveCall": {
-      const [pkg, module2, fn] = transaction.target.split("::");
       return {
         MoveCall: {
-          arguments: transaction.arguments.map(mapTransactionArgument),
-          function: fn,
-          module: module2,
-          package: pkg,
-          type_arguments: transaction.typeArguments
+          arguments: transaction.MoveCall.arguments.map(mapTransactionArgument),
+          function: transaction.MoveCall.function,
+          module: transaction.MoveCall.module,
+          package: transaction.MoveCall.package,
+          type_arguments: transaction.MoveCall.typeArguments
         }
       };
     }
     case "MakeMoveVec": {
       return {
         MakeMoveVec: [
-          "Some" in transaction.type ? import_bcs2.TypeTagSerializer.tagToString(transaction.type.Some) : null,
-          transaction.objects.map(mapTransactionArgument)
+          transaction.MakeMoveVec.type,
+          transaction.MakeMoveVec.elements.map(mapTransactionArgument)
         ]
       };
     }
     case "MergeCoins": {
       return {
         MergeCoins: [
-          mapTransactionArgument(transaction.destination),
-          transaction.sources.map(mapTransactionArgument)
+          mapTransactionArgument(transaction.MergeCoins.destination),
+          transaction.MergeCoins.sources.map(mapTransactionArgument)
         ]
       };
     }
     case "Publish": {
       return {
-        Publish: transaction.modules.map((module2) => (0, import_bcs.toB64)(Uint8Array.from(module2)))
+        Publish: transaction.Publish.modules.map((module2) => module2)
       };
     }
     case "SplitCoins": {
       return {
         SplitCoins: [
-          mapTransactionArgument(transaction.coin),
-          transaction.amounts.map(mapTransactionArgument)
+          mapTransactionArgument(transaction.SplitCoins.coin),
+          transaction.SplitCoins.amounts.map(mapTransactionArgument)
         ]
       };
     }
     case "TransferObjects": {
       return {
         TransferObjects: [
-          transaction.objects.map(mapTransactionArgument),
-          mapTransactionArgument(transaction.address)
+          transaction.TransferObjects.objects.map(mapTransactionArgument),
+          mapTransactionArgument(transaction.TransferObjects.address)
         ]
       };
     }
     case "Upgrade": {
       return {
         Upgrade: [
-          transaction.modules.map((module2) => (0, import_bcs.toB64)(Uint8Array.from(module2))),
-          transaction.packageId,
-          mapTransactionArgument(transaction.ticket)
+          transaction.Upgrade.modules.map((module2) => module2),
+          transaction.Upgrade.package,
+          mapTransactionArgument(transaction.Upgrade.ticket)
         ]
       };
     }
@@ -289,26 +280,205 @@ function mapTransaction(transaction) {
   throw new Error(`Unknown transaction type ${transaction}`);
 }
 function mapTransactionArgument(arg) {
-  switch (arg.kind) {
+  switch (arg.$kind) {
     case "GasCoin": {
       return "GasCoin";
     }
     case "Input": {
       return {
-        Input: arg.index
+        Input: arg.Input
       };
     }
     case "Result": {
       return {
-        Result: arg.index
+        Result: arg.Result
       };
     }
     case "NestedResult": {
       return {
-        NestedResult: [arg.index, arg.resultIndex]
+        NestedResult: arg.NestedResult
       };
     }
   }
   throw new Error(`Unknown argument type ${arg}`);
 }
+const OBJECT_DIGEST_DELETED = (0, import_bcs.toB58)(Uint8Array.from({ length: 32 }, () => 99));
+const OBJECT_DIGEST_WRAPPED = (0, import_bcs.toB58)(Uint8Array.from({ length: 32 }, () => 88));
+const OBJECT_DIGEST_ZERO = (0, import_bcs.toB58)(Uint8Array.from({ length: 32 }, () => 0));
+const ADDRESS_ZERO = (0, import_utils.normalizeIotaAddress)("0x0");
+function mapEffects(data) {
+  const effects = import_bcs2.bcs.TransactionEffects.parse((0, import_bcs.fromB64)(data));
+  const sharedObjects = effects.V1.unchangedSharedObjects.map(([id, sharedObject]) => {
+    switch (sharedObject.$kind) {
+      case "ReadOnlyRoot":
+        return {
+          objectId: id,
+          version: Number(sharedObject.ReadOnlyRoot[0]),
+          digest: sharedObject.ReadOnlyRoot[1]
+        };
+      case "MutateDeleted":
+        return {
+          objectId: id,
+          version: Number(sharedObject.MutateDeleted),
+          digest: OBJECT_DIGEST_DELETED
+        };
+      case "ReadDeleted":
+        return {
+          objectId: id,
+          version: Number(sharedObject.ReadDeleted),
+          digest: OBJECT_DIGEST_DELETED
+        };
+      default:
+        throw new Error(`Unknown shared object type: ${sharedObject}`);
+    }
+  });
+  effects.V1.changedObjects.filter(([_id, change]) => change.inputState.Exist?.[1].Shared).forEach(([id, change]) => {
+    sharedObjects.push({
+      objectId: id,
+      version: Number(change.inputState.Exist[0][0]),
+      digest: change.inputState.Exist[0][1]
+    });
+  });
+  const modifiedAtVersions = effects.V1.changedObjects.filter(([_id, change]) => change.inputState.Exist).map(([id, change]) => [id, change.inputState.Exist[0][0]]);
+  const created = effects.V1.changedObjects.filter(
+    ([_id, change]) => change.inputState.NotExist && (change.outputState.ObjectWrite || change.outputState.PackageWrite) && change.idOperation.Created
+  ).map(
+    ([objectId, change]) => change.outputState.PackageWrite ? [
+      {
+        objectId,
+        version: Number(change.outputState.PackageWrite[0]),
+        digest: change.outputState.PackageWrite[1]
+      },
+      { $kind: "Immutable", Immutable: true }
+    ] : [
+      {
+        objectId,
+        version: Number(effects.V1.lamportVersion),
+        digest: change.outputState.ObjectWrite[0]
+      },
+      change.outputState.ObjectWrite[1]
+    ]
+  );
+  const mutated = effects.V1.changedObjects.filter(
+    ([_id, change]) => change.inputState.Exist && (change.outputState.ObjectWrite || change.outputState.PackageWrite)
+  ).map(([objectId, change]) => [
+    change.outputState.PackageWrite ? {
+      objectId,
+      version: Number(change.outputState.PackageWrite[0]),
+      digest: change.outputState.PackageWrite[1]
+    } : {
+      objectId,
+      version: Number(effects.V1.lamportVersion),
+      digest: change.outputState.ObjectWrite[0]
+    },
+    change.outputState.ObjectWrite ? change.outputState.ObjectWrite[1] : { $kind: "Immutable", Immutable: true }
+  ]);
+  const unwrapped = effects.V1.changedObjects.filter(
+    ([_id, change]) => change.inputState.NotExist && change.outputState.ObjectWrite && change.idOperation.None
+  ).map(([objectId, change]) => [
+    {
+      objectId,
+      version: Number(effects.V1.lamportVersion),
+      digest: change.outputState.ObjectWrite[0]
+    },
+    change.outputState.ObjectWrite[1]
+  ]);
+  const deleted = effects.V1.changedObjects.filter(
+    ([_id, change]) => change.inputState.Exist && change.outputState.NotExist && change.idOperation.Deleted
+  ).map(([objectId, _change]) => ({
+    objectId,
+    version: Number(effects.V1.lamportVersion),
+    digest: OBJECT_DIGEST_DELETED
+  }));
+  const unwrappedThenDeleted = effects.V1.changedObjects.filter(
+    ([_id, change]) => change.inputState.NotExist && change.outputState.NotExist && change.idOperation.Deleted
+  ).map(([objectId, _change]) => ({
+    objectId,
+    version: Number(effects.V1.lamportVersion),
+    digest: OBJECT_DIGEST_DELETED
+  }));
+  const wrapped = effects.V1.changedObjects.filter(
+    ([_id, change]) => change.inputState.Exist && change.outputState.NotExist && change.idOperation.None
+  ).map(([objectId, _change]) => ({
+    objectId,
+    version: Number(effects.V1.lamportVersion),
+    digest: OBJECT_DIGEST_WRAPPED
+  }));
+  const gasObjectFromV1 = effects.V1.gasObjectIndex != null ? effects.V1.changedObjects[effects.V1.gasObjectIndex] : null;
+  const gasObject = gasObjectFromV1 ? [
+    {
+      objectId: gasObjectFromV1[0],
+      digest: gasObjectFromV1[1].outputState.ObjectWrite[0],
+      version: Number(effects.V1.lamportVersion)
+    },
+    gasObjectFromV1[1].outputState.ObjectWrite[1]
+  ] : [
+    {
+      objectId: ADDRESS_ZERO,
+      version: "0",
+      digest: OBJECT_DIGEST_ZERO
+    },
+    {
+      $kind: "AddressOwner",
+      AddressOwner: ADDRESS_ZERO
+    }
+  ];
+  return {
+    messageVersion: "v1",
+    status: effects.V1.status.Success ? {
+      status: "success"
+    } : {
+      status: "failure",
+      // TODO: we don't have the error message from bcs effects
+      error: effects.V1.status.$kind
+    },
+    executedEpoch: effects.V1.executedEpoch,
+    gasUsed: effects.V1.gasUsed,
+    modifiedAtVersions: modifiedAtVersions.map(([objectId, sequenceNumber]) => ({
+      objectId,
+      sequenceNumber
+    })),
+    ...sharedObjects.length === 0 ? {} : { sharedObjects },
+    transactionDigest: effects.V1.transactionDigest,
+    ...created.length === 0 ? {} : {
+      created: created.map(([reference, owner]) => ({
+        reference,
+        owner: mapEffectsOwner(owner)
+      }))
+    },
+    ...mutated.length === 0 ? {} : {
+      mutated: mutated.map(([reference, owner]) => ({
+        reference,
+        owner: mapEffectsOwner(owner)
+      }))
+    },
+    ...unwrapped.length === 0 ? {} : {
+      unwrapped: unwrapped.length === 0 ? void 0 : unwrapped.map(([reference, owner]) => ({
+        reference,
+        owner: mapEffectsOwner(owner)
+      }))
+    },
+    ...deleted.length === 0 ? {} : { deleted },
+    ...unwrappedThenDeleted.length === 0 ? {} : { unwrappedThenDeleted },
+    ...wrapped.length === 0 ? {} : { wrapped },
+    gasObject: {
+      reference: gasObject[0],
+      owner: mapEffectsOwner(gasObject[1])
+    },
+    ...effects.V1.eventsDigest ? { eventsDigest: effects.V1.eventsDigest } : {},
+    dependencies: effects.V1.dependencies
+  };
+  function mapEffectsOwner(owner) {
+    if (owner.Immutable) {
+      return "Immutable";
+    } else if (owner.Shared) {
+      return { Shared: { initial_shared_version: owner.Shared.initialSharedVersion } };
+    } else if (owner.AddressOwner) {
+      return { AddressOwner: owner.AddressOwner };
+    } else if (owner.ObjectOwner) {
+      return { ObjectOwner: owner.ObjectOwner };
+    }
+    throw new Error(`Unknown owner type: ${owner}`);
+  }
+}
 //# sourceMappingURL=transaction-block.js.map