JAV-3 [Github #244]

Made optional of:
- previousRestrictionValue (MosaicAddressRestrictionTx)
- referenceMosaicId (MosaicGlobalRestrictionTx)

Author: rg911

e2e/infrastructure/TransactionHttp.spec.ts

@@ -419,7 +419,6 @@ describe('TransactionHttp', () => {
             const mosaicGlobalRestrictionTransaction = MosaicGlobalRestrictionTransaction.create(
                 Deadline.create(),
                 mosaicId,
-                new MosaicId(UInt64.fromUint(0).toDTO()),
                 UInt64.fromUint(60641),
                 UInt64.fromUint(0),
                 MosaicRestrictionType.NONE,
@@ -453,7 +452,6 @@ describe('TransactionHttp', () => {
             const mosaicGlobalRestrictionTransaction = MosaicGlobalRestrictionTransaction.create(
                 Deadline.create(),
                 mosaicId,
-                new MosaicId(UInt64.fromUint(0).toDTO()),
                 UInt64.fromUint(60641),
                 UInt64.fromUint(0),
                 MosaicRestrictionType.GE,
@@ -494,7 +492,6 @@ describe('TransactionHttp', () => {
                 mosaicId,
                 UInt64.fromUint(60641),
                 account3.address,
-                UInt64.fromHex('FFFFFFFFFFFFFFFF'),
                 UInt64.fromUint(2),
                 NetworkType.MIJIN_TEST,
             );

src/model/transaction/MosaicAddressRestrictionTransaction.ts

@@ -54,19 +54,19 @@ export class MosaicAddressRestrictionTransaction extends Transaction {
      * @param mosaicId - The mosaic id ex: new MosaicId([481110499, 231112638]).
      * @param restrictionKey - The restriction key.
      * @param targetAddress - The affected unresolved address.
-     * @param previousRestrictionValue - The previous restriction value.
      * @param newRestrictionValue - The new restriction value.
      * @param networkType - The network type.
+     * @param previousRestrictionValue - (Optional) The previous restriction value.
      * @param maxFee - (Optional) Max fee defined by the sender
      * @returns {MosaicAddressRestrictionTransaction}
      */
     public static create(deadline: Deadline,
                          mosaicId: MosaicId,
                          restrictionKey: UInt64,
                          targetAddress: Address,
-                         previousRestrictionValue: UInt64,
                          newRestrictionValue: UInt64,
                          networkType: NetworkType,
+                         previousRestrictionValue: UInt64 = UInt64.fromHex('FFFFFFFFFFFFFFFF'),
                          maxFee: UInt64 = new UInt64([0, 0])): MosaicAddressRestrictionTransaction {
         return new MosaicAddressRestrictionTransaction(networkType,
             TransactionVersion.MOSAIC_ADDRESS_RESTRICTION,
@@ -140,9 +140,9 @@ export class MosaicAddressRestrictionTransaction extends Transaction {
             new MosaicId(builder.getMosaicId().unresolvedMosaicId),
             new UInt64(builder.getRestrictionKey()),
             Address.createFromEncoded(Convert.uint8ToHex(builder.getTargetAddress().unresolvedAddress)),
-            new UInt64(builder.getPreviousRestrictionValue()),
             new UInt64(builder.getNewRestrictionValue()),
             networkType,
+            new UInt64(builder.getPreviousRestrictionValue()),
             isEmbedded ? new UInt64([0, 0]) : new UInt64((builder as MosaicAddressRestrictionTransactionBuilder).fee.amount),
         );
         return isEmbedded ?

src/model/transaction/MosaicGlobalRestrictionTransaction.ts

@@ -54,25 +54,25 @@ export class MosaicGlobalRestrictionTransaction extends Transaction {
      *
      * @param deadline - The deadline to include the transaction.
      * @param mosaicId - The mosaic id ex: new MosaicId([481110499, 231112638]).
-     * @param referenceMosaicId - The mosaic id providing the restriction key.
      * @param restrictionKey - The restriction key.
      * @param previousRestrictionValue - The previous restriction value.
      * @param previousRestrictionType - The previous restriction type.
      * @param newRestrictionValue - The new restriction value.
      * @param previousRestrictionType - The previous restriction tpye.
      * @param networkType - The network type.
+     * @param referenceMosaicId - (Optional) The mosaic id providing the restriction key.
      * @param maxFee - (Optional) Max fee defined by the sender
      * @returns {MosaicGlobalRestrictionTransaction}
      */
     public static create(deadline: Deadline,
                          mosaicId: MosaicId,
-                         referenceMosaicId: MosaicId,
                          restrictionKey: UInt64,
                          previousRestrictionValue: UInt64,
                          previousRestrictionType: MosaicRestrictionType,
                          newRestrictionValue: UInt64,
                          newRestrictionType: MosaicRestrictionType,
                          networkType: NetworkType,
+                         referenceMosaicId: MosaicId = new MosaicId(UInt64.fromUint(0).toDTO()),
                          maxFee: UInt64 = new UInt64([0, 0])): MosaicGlobalRestrictionTransaction {
         return new MosaicGlobalRestrictionTransaction(networkType,
             TransactionVersion.MOSAIC_GLOBAL_RESTRICTION,
@@ -154,13 +154,13 @@ export class MosaicGlobalRestrictionTransaction extends Transaction {
             isEmbedded ? Deadline.create() : Deadline.createFromDTO(
                 (builder as MosaicGlobalRestrictionTransactionBuilder).getDeadline().timestamp),
             new MosaicId(builder.getMosaicId().unresolvedMosaicId),
-            new MosaicId(builder.getReferenceMosaicId().unresolvedMosaicId),
             new UInt64(builder.getRestrictionKey()),
             new UInt64(builder.getPreviousRestrictionValue()),
             builder.getPreviousRestrictionType().valueOf(),
             new UInt64(builder.getNewRestrictionValue()),
             builder.getNewRestrictionType().valueOf(),
             networkType,
+            new MosaicId(builder.getReferenceMosaicId().unresolvedMosaicId),
             isEmbedded ? new UInt64([0, 0]) : new UInt64((builder as MosaicGlobalRestrictionTransactionBuilder).fee.amount),
         );
         return isEmbedded ?

test/core/utils/TransactionMapping.spec.ts

@@ -534,7 +534,6 @@ describe('TransactionMapping - createFromPayload', () => {
         const mosaicGlobalRestrictionTransaction = MosaicGlobalRestrictionTransaction.create(
             Deadline.create(),
             new MosaicId(UInt64.fromUint(1).toDTO()),
-            new MosaicId(UInt64.fromUint(0).toDTO()),
             UInt64.fromUint(4444),
             UInt64.fromUint(0),
             MosaicRestrictionType.NONE,
@@ -564,8 +563,8 @@ describe('TransactionMapping - createFromPayload', () => {
             UInt64.fromUint(4444),
             account.address,
             UInt64.fromUint(0),
-            UInt64.fromUint(0),
             NetworkType.MIJIN_TEST,
+            UInt64.fromUint(0),
         );
 
         const signedTx = mosaicAddressRestrictionTransaction.signWith(account, generationHash);
@@ -1019,7 +1018,6 @@ describe('TransactionMapping - createFromDTO (Transaction.toJSON() feed)', () =>
         const mosaicGlobalRestrictionTransaction = MosaicGlobalRestrictionTransaction.create(
             Deadline.create(),
             new MosaicId(UInt64.fromUint(1).toDTO()),
-            new MosaicId(UInt64.fromUint(0).toDTO()),
             UInt64.fromUint(4444),
             UInt64.fromUint(0),
             MosaicRestrictionType.NONE,
@@ -1048,8 +1046,8 @@ describe('TransactionMapping - createFromDTO (Transaction.toJSON() feed)', () =>
             UInt64.fromUint(4444),
             account.address,
             UInt64.fromUint(0),
-            UInt64.fromUint(0),
             NetworkType.MIJIN_TEST,
+            UInt64.fromUint(0),
         );
 
         const transaction =

test/model/transaction/MosaicAddressRestrictionTransaction.spec.ts

@@ -37,9 +37,9 @@ describe('MosaicAddressRestrictionTransaction', () => {
             mosaicId,
             UInt64.fromUint(1),
             account.address,
-            UInt64.fromUint(9),
             UInt64.fromUint(8),
             NetworkType.MIJIN_TEST,
+            UInt64.fromUint(9),
         );
         expect(mosaicAddressRestrictionTransaction.mosaicId.toHex()).to.be.equal(mosaicId.toHex());
         expect(mosaicAddressRestrictionTransaction.restrictionKey.toHex()).to.be.equal(UInt64.fromUint(1).toHex());

test/model/transaction/MosaicGlobalRestrictionTransaction.spec.ts

@@ -37,13 +37,13 @@ describe('MosaicGlobalRestrictionTransaction', () => {
         const mosaicGlobalRestrictionTransaction = MosaicGlobalRestrictionTransaction.create(
             Deadline.create(),
             mosaicId,
-            referenceMosaicId,
             UInt64.fromUint(1),
             UInt64.fromUint(9),
             MosaicRestrictionType.EQ,
             UInt64.fromUint(8),
             MosaicRestrictionType.GE,
             NetworkType.MIJIN_TEST,
+            referenceMosaicId,
         );
 
         expect(mosaicGlobalRestrictionTransaction.mosaicId.toHex()).to.be.equal(mosaicId.toHex());