0.12 Updates (#10)

bower.json

@@ -18,18 +18,18 @@
     "output"
   ],
   "dependencies": {
-    "purescript-prelude": "^3.3.0",
-    "purescript-modules": "^3.0.0",
-    "purescript-foreign": "^4.0.1",
-    "purescript-simple-json": "^3.0.0",
-    "purescript-sets": "^3.2.0",
-    "purescript-bytestrings": "^6.0.0",
-    "purescript-simple-json": "^3.0.0",
-    "purescript-argonaut": "^3.1.0"
+    "purescript-prelude": "^4.0.0",
+    "purescript-ring-modules": "^5.0.1",
+    "purescript-foreign-generic": "^7.0.0",
+    "purescript-simple-json": "^4.0.0",
+    "purescript-ordered-collections": "^1.0.0",
+    "purescript-bytestrings": "^7.0.0",
+    "purescript-simple-json": "^4.0.0",
+    "purescript-argonaut": "^4.0.0"
   },
   "devDependencies": {
-    "purescript-psci-support": "^3.0.0",
-    "purescript-spec": "^2.0.0",
-    "purescript-debug": "^3.0.0"
+    "purescript-psci-support": "^4.0.0",
+    "purescript-spec": "^3.0.0",
+    "purescript-debug": "^4.0.0"
   }
 }

package.json

@@ -14,8 +14,9 @@
   },
   "devDependencies": {
     "bower": "^1.8.4",
-    "pulp": "^12.0.1",
-    "purescript": "^0.11.7"
+    "purescript-psa": "^0.6.0",
+    "purescript": "^0.12.0",
+    "pulp": "^12.2.0"
   },
   "scripts": {
     "postinstall": "bower i",

src/Network/Ethereum/Core/BigNumber.purs

@@ -15,11 +15,11 @@ import Prelude
 
 import Data.Argonaut as A
 import Data.Either (Either(..), either)
-import Data.Foreign (ForeignError(..), readString, fail)
-import Data.Foreign.Class (class Decode, class Encode, decode, encode)
+import Foreign (ForeignError(..), readString, fail)
+import Foreign.Class (class Decode, class Encode, decode, encode)
 import Data.Int (Radix, binary, decimal, hexadecimal, floor) as Int
 import Data.Maybe (Maybe(..))
-import Data.Module (class LeftModule, class RightModule)
+import Data.Ring.Module (class LeftModule, class RightModule)
 import Simple.JSON (class ReadForeign, class WriteForeign)
 
 --------------------------------------------------------------------------------

src/Network/Ethereum/Core/HexString.purs

@@ -32,13 +32,13 @@ import Data.Argonaut as A
 import Data.Array (uncons, unsafeIndex, replicate)
 import Data.ByteString (ByteString, toString, fromString) as BS
 import Data.Either (Either(..), either)
-import Data.Foreign (ForeignError(..), fail)
-import Data.Foreign.Class (class Decode, class Encode, decode, encode)
+import Foreign (ForeignError(..), fail)
+import Foreign.Class (class Decode, class Encode, decode, encode)
 import Data.Int (even)
 import Data.Maybe (Maybe(..), fromJust, isJust)
-import Data.Monoid (class Monoid)
 import Data.Set (fromFoldable, member) as Set
-import Data.String (Pattern(..), split, fromCharArray, stripPrefix, toCharArray)
+import Data.String.CodeUnits (fromCharArray, toCharArray)
+import Data.String (Pattern(..), split, stripPrefix)
 import Data.String as S
 import Network.Ethereum.Core.BigNumber (BigNumber, toString, hexadecimal)
 import Node.Encoding (Encoding(Hex, UTF8, ASCII))

src/Network/Ethereum/Core/Signatures.purs

@@ -26,8 +26,8 @@ import Data.ByteString as BS
 import Data.Either (Either(..), either)
 import Data.Function.Uncurried (Fn2, Fn3, runFn2, runFn3)
 import Data.Maybe (Maybe(..), fromJust)
-import Data.Foreign (ForeignError(..), fail)
-import Data.Foreign.Class (class Decode, class Encode, decode, encode)
+import Foreign (ForeignError(..), fail)
+import Foreign.Class (class Decode, class Encode, decode, encode)
 import Data.Generic.Rep (class Generic)
 import Data.Generic.Rep.Show (genericShow)
 import Network.Ethereum.Core.HexString (HexString, dropHex, hexLength, toByteString, fromByteString)

test/Main.purs

@@ -2,16 +2,16 @@ module Test.Main where
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
+import Effect (Effect)
 import Test.Spec.Reporter.Console (consoleReporter)
-import Test.Spec.Runner (RunnerEffects, run)
+import Test.Spec.Runner (run)
 import CoreSpec.BigNumber (bigNumberSpec)
 import CoreSpec.Hex (hexSpec)
 import CoreSpec.Keccak256 (keccak256Spec)
 import CoreSpec.RLP (rlpSpec)
 import CoreSpec.Signatures (signatureSpec)
 
-main :: Eff (RunnerEffects ()) Unit
+main :: Effect Unit
 main = run [consoleReporter] $ do
   keccak256Spec
   hexSpec

test/Spec/BigNumber.purs

@@ -6,8 +6,8 @@ import Prelude
 import Control.Monad.Except (runExcept)
 import Data.Argonaut as A
 import Data.Either (Either(..), fromRight)
-import Data.Foreign (toForeign)
-import Data.Foreign.Class (decode, encode)
+import Foreign (unsafeToForeign)
+import Foreign.Class (decode, encode)
 import Data.Maybe (Maybe(..), fromJust)
 import Network.Ethereum.Core.BigNumber (BigNumber, decimal, embed, hexadecimal, parseBigNumber, divide)
 import Partial.Unsafe (unsafePartial)
@@ -16,7 +16,7 @@ import Test.Spec (Spec, describe, it)
 import Test.Spec.Assertions (shouldEqual)
 
 
-bigNumberSpec :: forall r . Spec r Unit
+bigNumberSpec :: Spec Unit
 bigNumberSpec = describe "BigNumber-spec" do
 
     describe "toBigNumber tests" do
@@ -70,8 +70,8 @@ bigNumberSpec = describe "BigNumber-spec" do
 
       it "can handle deserialization" do
         let bnString = "f43"
-            d1 = unsafePartial $ fromRight $ runExcept $ readImpl (toForeign bnString)
-            d2 = unsafePartial $ fromRight $ runExcept $ decode (toForeign bnString)
+            d1 = unsafePartial $ fromRight $ runExcept $ readImpl (unsafeToForeign bnString)
+            d2 = unsafePartial $ fromRight $ runExcept $ decode (unsafeToForeign bnString)
             d3 = unsafePartial $ fromRight $ A.decodeJson (A.fromString bnString)
             d4 = unsafePartial $ fromJust $ parseBigNumber hexadecimal bnString
         d4 `shouldEqual` d1

test/Spec/Hex.purs

@@ -6,8 +6,8 @@ import Control.Monad.Except (runExcept)
 import Data.Argonaut as A
 import Data.ByteString as BS
 import Data.Either (Either(..), fromRight)
-import Data.Foreign (toForeign)
-import Data.Foreign.Class (encode, decode)
+import Foreign (unsafeToForeign)
+import Foreign.Class (encode, decode)
 import Data.Maybe (Maybe(Just), fromJust)
 import Network.Ethereum.Core.HexString (HexString, mkHexString, toByteString, toUtf8, toAscii, fromUtf8, fromAscii)
 import Node.Encoding (Encoding(Hex))
@@ -16,7 +16,7 @@ import Simple.JSON (readImpl)
 import Test.Spec (Spec, describe, it)
 import Test.Spec.Assertions (shouldEqual)
 
-hexSpec :: forall r . Spec r Unit
+hexSpec :: Spec Unit
 hexSpec = describe "hex-spec" do
 
     describe "bytestringFromHexString" do
@@ -59,13 +59,13 @@ hexSpec = describe "hex-spec" do
 
         let hx = (unsafePartial (fromJust <<< mkHexString) "0x6d79537472696e67")
             hxJson = A.fromString "0x6d79537472696e67"
-        (A.encodeJson <$> (A.decodeJson hxJson :: Either String HexString)) `shouldEqual` Right hxJson
+        (A.stringify <<< A.encodeJson <$> (A.decodeJson hxJson :: Either String HexString)) `shouldEqual` Right (A.stringify hxJson)
         A.decodeJson (A.encodeJson hx) `shouldEqual` Right hx
 
       it "can handle deserialization" do
         let hxString = "0f43"
-            d1 = unsafePartial $ fromRight $ runExcept $ readImpl (toForeign hxString)
-            d2 = unsafePartial $ fromRight $ runExcept $ decode (toForeign hxString)
+            d1 = unsafePartial $ fromRight $ runExcept $ readImpl (unsafeToForeign hxString)
+            d2 = unsafePartial $ fromRight $ runExcept $ decode (unsafeToForeign hxString)
             d3 = unsafePartial $ fromRight $ A.decodeJson (A.fromString hxString)
             d4 = unsafePartial $ fromJust $ mkHexString hxString
         d4 `shouldEqual` d1

test/Spec/Keccak256.purs

@@ -10,7 +10,7 @@ import Partial.Unsafe (unsafePartial)
 import Test.Spec (Spec, describe, it)
 import Test.Spec.Assertions (shouldEqual)
 
-keccak256Spec :: forall r . Spec r Unit
+keccak256Spec :: Spec Unit
 keccak256Spec = describe "keccak256-spec" do
     describe "Keccak256 tests" do
       it "can hash strings" do

test/Spec/RLP.purs

@@ -5,7 +5,6 @@ import Prelude
 import Common (RawTransaction(..), makeTransactionMessage, mkAddress', mkHexString')
 import Data.ByteString as BS
 import Data.Maybe (Maybe(..), fromJust)
-import Data.Monoid (mempty)
 import Network.Ethereum.Core.BigNumber (embed, pow)
 import Network.Ethereum.Core.Keccak256 (keccak256)
 import Network.Ethereum.Core.RLP as RLP
@@ -14,10 +13,9 @@ import Node.Encoding (Encoding(Hex, UTF8))
 import Partial.Unsafe (unsafePartial)
 import Test.Spec (Spec, it, describe)
 import Test.Spec.Assertions (shouldEqual)
-import Test.Spec.Runner (RunnerEffects)
 import Type.Quotient (mkQuotient)
 
-rlpSpec :: Spec (RunnerEffects ()) Unit
+rlpSpec :: Spec Unit
 rlpSpec = do
 
   describe "RLP Spec" $ do

test/Spec/Signatures.purs

@@ -3,16 +3,15 @@ module CoreSpec.Signatures (signatureSpec) where
 import Prelude
 
 import Common (RawTransaction(..), makeTransactionMessage, mkAddress', mkHexString', mkPrivateKey')
-import Control.Monad.Aff (Aff)
+import Effect.Aff (Aff)
 import Data.Maybe (Maybe(..))
 import Network.Ethereum.Core.BigNumber (embed)
 import Network.Ethereum.Core.Keccak256 (keccak256)
 import Network.Ethereum.Core.Signatures as Sig
 import Test.Spec (Spec, it, describe)
 import Test.Spec.Assertions (shouldEqual)
-import Test.Spec.Runner (RunnerEffects)
 
-signatureSpec :: Spec (RunnerEffects ()) Unit
+signatureSpec :: Spec Unit
 signatureSpec = do
   describe "Testing Public / PrivateKeys" $ do
 
@@ -55,10 +54,9 @@ signatureSpec = do
 --------------------------------------------------------------------------------
 
 validatePrivatePublicPair
-  :: forall r.
-     Sig.PrivateKey
+  :: Sig.PrivateKey
   -> Sig.PublicKey
-  -> Aff r Unit
+  -> Aff Unit
 validatePrivatePublicPair private public = do
   let mpublic = Sig.mkPublicKey <<< Sig.unPublicKey $ public
   mpublic `shouldEqual` Just public