Merge pull request #1166 from aeternity/release/8.0.0

Author: mradkov

CHANGELOG.md

@@ -1,3 +1,12 @@
+# [8.0.0](https://github.com/aeternity/aepp-sdk-js/compare/8.0.0-beta.2...8.0.0) (2021-05-18)
+
+
+### Bug Fixes
+
+* avoid instanceof between possible not/polyfilled objects ([906ee0e](https://github.com/aeternity/aepp-sdk-js/commit/906ee0ea4eb71160c3a482ea068cbb0d857cef8f))
+
+
+
 ## [8.0.0-beta.2](https://github.com/aeternity/aepp-sdk-js/compare/8.0.0-beta.1...8.0.0-beta.2) (2021-05-12)
 
 
@@ -10,7 +19,7 @@
 * avoid ts definitions based on broken JsDoc ([572d19f](https://github.com/aeternity/aepp-sdk-js/commit/572d19f5ae6bd549c92a1a37452c0270490b9f6e))
 
 
-# [8.0.0-beta.1](https://github.com/aeternity/aepp-sdk-js/compare/7.7.0...8.0.0-beta.1) (2021-05-6)
+## [8.0.0-beta.1](https://github.com/aeternity/aepp-sdk-js/compare/7.7.0...8.0.0-beta.1) (2021-05-6)
 
 
 ### Important changes

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeternity/aepp-sdk",
-  "version": "8.0.0-beta.2",
+  "version": "8.0.0",
   "description": "SDK for the æternity blockchain",
   "main": "dist/aepp-sdk.js",
   "types": "es/index.d.ts",
@@ -106,6 +106,7 @@
   },
   "files": [
     "dist",
+    "src",
     "es"
   ]
 }

package.json

@@ -233,25 +233,21 @@ export function transformVariant (value, generic, { bindings }) {
 }
 
 export function transformMap (value, generic, { bindings }) {
-  if (value instanceof Map) {
-    value = Array.from(value.entries())
-  }
-  if (!Array.isArray(value) && value instanceof Object) {
-    value = Object.entries(value)
+  if (!Array.isArray(value)) {
+    if (value.entries) value = Array.from(value.entries())
+    else if (value instanceof Object) value = Object.entries(value)
   }
 
-  return `{${value
-    .reduce(
-      (acc, [key, value], i) => {
-        if (i !== 0) acc += ','
-        acc += `[${transform(generic[0], key, {
-          bindings
-        })}] = ${transform(generic[1], value, { bindings })}`
-        return acc
-      },
-      ''
-    )
-  }}`
+  return [
+    '{',
+    value
+      .map(([key, value]) => [
+        `[${transform(generic[0], key, { bindings })}]`,
+        transform(generic[1], value, { bindings })
+      ].join(' = '))
+      .join(),
+    '}'
+  ].join('')
 }
 
 // FUNCTION RETURN VALUE TRANSFORMATION ↓↓↓

src/contract/aci/transformation.js

@@ -803,7 +803,7 @@ describe('Contract', function () {
         })
         it('Valid', async () => {
           const { decodedResult } = await contractObject.methods.tupleFn(['test', 1])
-          JSON.stringify(decodedResult).should.be.equal(JSON.stringify(['test', 1]))
+          decodedResult.should.be.eql(['test', 1])
         })
       })
       describe('LIST', function () {
@@ -830,88 +830,57 @@ describe('Contract', function () {
         })
         it('Valid', async () => {
           const { decodedResult } = await contractObject.methods.listInListFn([[1, 2], [3, 4]])
-          JSON.stringify(decodedResult).should.be.equal(JSON.stringify([[1, 2], [3, 4]]))
+          decodedResult.should.be.eql([[1, 2], [3, 4]])
         })
       })
+
       describe('MAP', function () {
+        const address = 'ak_gvxNbZf5CuxYVfcUFoKAP4geZatWaC2Yy4jpx5vZoCKank4Gc'
+
         it('Valid', async () => {
-          const address = await contract.address()
-          const mapArg = new Map(
-            [
-              [address, ['someStringV', 324]]
-            ]
-          )
-          const objectFromMap = Array.from(mapArg.entries()).reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {})
-          const { decodedResult } = await contractObject.methods.mapFn(objectFromMap)
-          JSON.stringify(decodedResult).should.be.equal(JSON.stringify(Array.from(mapArg.entries())))
+          const mapArg = new Map([[address, ['someStringV', 324]]])
+          const { decodedResult } = await contractObject.methods.mapFn(Object.fromEntries(mapArg))
+          decodedResult.should.be.eql(Array.from(mapArg.entries()))
         })
+
         it('Map With Option Value', async () => {
-          const address = await contract.address()
-          const mapArgWithSomeValue = new Map(
-            [
-              [address, ['someStringV', 123]]
-            ]
-          )
-          const mapArgWithNoneValue = new Map(
-            [
-              [address, ['someStringV', undefined]]
-            ]
-          )
-          const returnArgWithSomeValue = new Map(
-            [
-              [address, ['someStringV', 123]]
-            ]
-          )
-          const returnArgWithNoneValue = new Map(
-            [
-              [address, ['someStringV', undefined]]
-            ]
-          )
-          const resultWithSome = await contractObject.methods.mapOptionFn(mapArgWithSomeValue)
-          const resultWithNone = await contractObject.methods.mapOptionFn(mapArgWithNoneValue)
-
-          const decodedSome = resultWithSome.decodedResult
-
-          JSON.stringify(decodedSome).should.be.equal(JSON.stringify(Array.from(returnArgWithSomeValue.entries())))
-          JSON.stringify(resultWithNone.decodedResult).should.be.equal(JSON.stringify(Array.from(returnArgWithNoneValue.entries())))
+          const mapWithSomeValue = new Map([[address, ['someStringV', 123]]])
+          const mapWithNoneValue = new Map([[address, ['someStringV', undefined]]])
+          let result = await contractObject.methods.mapOptionFn(mapWithSomeValue)
+          result.decodedResult.should.be.eql(Array.from(mapWithSomeValue.entries()))
+          result = await contractObject.methods.mapOptionFn(mapWithNoneValue)
+          result.decodedResult.should.be.eql(Array.from(mapWithNoneValue.entries()))
         })
+
         it('Cast from string to int', async () => {
-          const address = await contract.address()
-          const mapArg = new Map(
-            [
-              [address, ['someStringV', '324']]
-            ]
-          )
+          const mapArg = new Map([[address, ['someStringV', '324']]])
           const result = await contractObject.methods.mapFn(mapArg)
           mapArg.set(address, ['someStringV', 324])
-          JSON.stringify(result.decodedResult).should.be.equal(JSON.stringify(Array.from(mapArg.entries())))
+          result.decodedResult.should.be.eql(Array.from(mapArg.entries()))
         })
+
         it('Cast from array to map', async () => {
-          const address = await contract.address()
-          const mapArg =
-            [
-              [address, ['someStringV', 324]]
-            ]
+          const mapArg = [[address, ['someStringV', 324]]]
           const { decodedResult } = await contractObject.methods.mapFn(mapArg)
-          JSON.stringify(decodedResult).should.be.equal(JSON.stringify(mapArg))
+          decodedResult.should.be.eql(mapArg)
         })
       })
+
       describe('RECORD/STATE', function () {
-        const objEq = (obj, obj2) => !Object.entries(obj).find(([key, val]) => JSON.stringify(obj2[key]) !== JSON.stringify(val))
         it('Valid Set Record (Cast from JS object)', async () => {
           await contractObject.methods.setRecord({ value: 'qwe', key: 1234, testOption: 'test' })
           const state = await contractObject.methods.getRecord()
 
-          objEq(state.decodedResult, { value: 'qwe', key: 1234, testOption: 'test' }).should.be.equal(true)
+          state.decodedResult.should.be.eql({ value: 'qwe', key: 1234, testOption: 'test' })
         })
         it('Get Record(Convert to JS object)', async () => {
           const result = await contractObject.methods.getRecord()
-          objEq(result.decodedResult, { value: 'qwe', key: 1234, testOption: 'test' }).should.be.equal(true)
+          result.decodedResult.should.be.eql({ value: 'qwe', key: 1234, testOption: 'test' })
         })
         it('Get Record With Option (Convert to JS object)', async () => {
           await contractObject.methods.setRecord({ key: 1234, value: 'qwe', testOption: 'resolved string' })
           const result = await contractObject.methods.getRecord()
-          objEq(result.decodedResult, { value: 'qwe', key: 1234, testOption: 'resolved string' }).should.be.equal(true)
+          result.decodedResult.should.be.eql({ value: 'qwe', key: 1234, testOption: 'resolved string' })
         })
         it('Invalid value type', async () => {
           try {
@@ -930,7 +899,7 @@ describe('Contract', function () {
         it('Set Some Option List Value(Cast from JS value/Convert result to JS)', async () => {
           const optionRes = await contractObject.methods.listOption([[1, 'testString']])
 
-          JSON.stringify(optionRes.decodedResult).should.be.equal(JSON.stringify([[1, 'testString']]))
+          optionRes.decodedResult.should.be.eql([[1, 'testString']])
         })
         it('Set None Option Value(Cast from JS value/Convert to JS)', async () => {
           const optionRes = await contractObject.methods.intOption(undefined)
@@ -980,7 +949,7 @@ describe('Contract', function () {
         })
         it('Valid', async () => {
           const res = await contractObject.methods.datTypeFn('Year')
-          JSON.stringify(res.decodedResult).should.be.equal('"Year"')
+          res.decodedResult.should.be.equal('Year')
         })
       })
       describe('Hash', function () {
@@ -1078,9 +1047,8 @@ describe('Contract', function () {
         contractObject.setOptions({ skipTransformDecoded: true })
         const res = await contractObject.methods.listFn([1, 2])
         const decoded = await res.decode()
-        const decodedJSON = JSON.stringify([1, 2])
         contractObject.setOptions({ skipTransformDecoded: false })
-        JSON.stringify(decoded).should.be.equal(decodedJSON)
+        decoded.should.be.eql([1, 2])
       })
       it('Call contract with contract type argument', async () => {
         const result = await contractObject.methods.approve(0, 'ct_AUUhhVZ9de4SbeRk8ekos4vZJwMJohwW5X8KQjBMUVduUmoUh')

test/integration/contract.js

@@ -36,7 +36,7 @@ describe('Verify Transaction', function () {
       .filter(({ type }) => type === 'warning')
       .map(({ txKey }) => txKey)
 
-    JSON.stringify(WARNINGS).should.be.equals(JSON.stringify(warning))
+    WARNINGS.should.be.eql(warning)
   })
   it('check errors', async () => {
     const spendTx = await client.spendTx({
@@ -60,7 +60,7 @@ describe('Verify Transaction', function () {
         .filter(({ type }) => type === 'error') // exclude contract vm/abi, has separated test for it
         .map(({ txKey }) => txKey)
 
-      JSON.stringify(ERRORS.filter(e => e !== 'gasPrice' && e !== 'ctVersion')).should.be.equals(JSON.stringify(error))
+      ERRORS.filter(e => e !== 'gasPrice' && e !== 'ctVersion').should.be.eql(error)
     }
     await checkErrors(signedTxHash)
     await checkErrors(signedTxFull)