Skip to content
Snippets Groups Projects
Commit b5ec7827 authored by Wolfgang Welz's avatar Wolfgang Welz
Browse files

Use iota.go

parent 9e45d490
No related branches found
No related tags found
No related merge requests found
Showing
with 213 additions and 157 deletions
...@@ -3,7 +3,6 @@ module github.com/iotaledger/goshimmer ...@@ -3,7 +3,6 @@ module github.com/iotaledger/goshimmer
go 1.12 go 1.12
require ( require (
github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9 // indirect
github.com/dgraph-io/badger v2.0.0-rc.2.0.20190610165348-a804ffa35fb9+incompatible github.com/dgraph-io/badger v2.0.0-rc.2.0.20190610165348-a804ffa35fb9+incompatible
github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 // indirect github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 // indirect
github.com/dustin/go-humanize v1.0.0 // indirect github.com/dustin/go-humanize v1.0.0 // indirect
...@@ -12,6 +11,7 @@ require ( ...@@ -12,6 +11,7 @@ require (
github.com/go-zeromq/zmq4 v0.4.0 github.com/go-zeromq/zmq4 v0.4.0
github.com/golang/protobuf v1.3.1 // indirect github.com/golang/protobuf v1.3.1 // indirect
github.com/google/open-location-code/go v0.0.0-20190603181809-cf814bded323 github.com/google/open-location-code/go v0.0.0-20190603181809-cf814bded323
github.com/iotaledger/iota.go v1.0.0-beta.6
github.com/labstack/echo v3.3.10+incompatible github.com/labstack/echo v3.3.10+incompatible
github.com/labstack/gommon v0.2.9 // indirect github.com/labstack/gommon v0.2.9 // indirect
github.com/magiconair/properties v1.8.1 github.com/magiconair/properties v1.8.1
......
...@@ -2,28 +2,42 @@ github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9 h1:HD8gA2tkBy ...@@ -2,28 +2,42 @@ github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9 h1:HD8gA2tkBy
github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8= github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8=
github.com/DATA-DOG/go-sqlmock v1.3.3 h1:CWUqKXe0s8A2z6qCgkP4Kru7wC11YoAnoupUKFDnH08= github.com/DATA-DOG/go-sqlmock v1.3.3 h1:CWUqKXe0s8A2z6qCgkP4Kru7wC11YoAnoupUKFDnH08=
github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM= github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
github.com/beevik/ntp v0.2.0/go.mod h1:hIHWr+l3+/clUnF44zdK+CWW7fO8dR5cIylAQ76NRpg=
github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgraph-io/badger v1.5.4/go.mod h1:VZxzAIRPHRVNRKRo6AXrX9BJegn6il06VMTZVJYCIjQ=
github.com/dgraph-io/badger v2.0.0-rc.2.0.20190610165348-a804ffa35fb9+incompatible h1:FE+hrPTLWIHxQzGTbjReHgpkj7+hFWC+L6b2fAxBG+I= github.com/dgraph-io/badger v2.0.0-rc.2.0.20190610165348-a804ffa35fb9+incompatible h1:FE+hrPTLWIHxQzGTbjReHgpkj7+hFWC+L6b2fAxBG+I=
github.com/dgraph-io/badger v2.0.0-rc.2.0.20190610165348-a804ffa35fb9+incompatible/go.mod h1:VZxzAIRPHRVNRKRo6AXrX9BJegn6il06VMTZVJYCIjQ= github.com/dgraph-io/badger v2.0.0-rc.2.0.20190610165348-a804ffa35fb9+incompatible/go.mod h1:VZxzAIRPHRVNRKRo6AXrX9BJegn6il06VMTZVJYCIjQ=
github.com/dgryski/go-farm v0.0.0-20190323231341-8198c7b169ec/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA=
github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo= github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
github.com/ethereum/go-ethereum v1.8.27 h1:d+gkiLaBDk5fn3Pe/xNVaMrB/ozI+AUB2IlVBp29IrY= github.com/ethereum/go-ethereum v1.8.27 h1:d+gkiLaBDk5fn3Pe/xNVaMrB/ozI+AUB2IlVBp29IrY=
github.com/ethereum/go-ethereum v1.8.27/go.mod h1:PwpWDrCLZrV+tfrhqqF6kPknbISMHaJv9Ln3kPCZLwY= github.com/ethereum/go-ethereum v1.8.27/go.mod h1:PwpWDrCLZrV+tfrhqqF6kPknbISMHaJv9Ln3kPCZLwY=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko= github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg= github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
github.com/gdamore/tcell v1.1.2 h1:Afe8cU6SECC06UmvaJ55Jr3Eh0tz/ywLjqWYqjGZp3s= github.com/gdamore/tcell v1.1.2 h1:Afe8cU6SECC06UmvaJ55Jr3Eh0tz/ywLjqWYqjGZp3s=
github.com/gdamore/tcell v1.1.2/go.mod h1:h3kq4HO9l2On+V9ed8w8ewqQEmGCSSHOgQ+2h8uzurE= github.com/gdamore/tcell v1.1.2/go.mod h1:h3kq4HO9l2On+V9ed8w8ewqQEmGCSSHOgQ+2h8uzurE=
github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
github.com/go-zeromq/zmq4 v0.4.0 h1:/TAahvAez7b6ycAyrxwN6Q36zy2OU8++uRLt6CwC74g= github.com/go-zeromq/zmq4 v0.4.0 h1:/TAahvAez7b6ycAyrxwN6Q36zy2OU8++uRLt6CwC74g=
github.com/go-zeromq/zmq4 v0.4.0/go.mod h1:Sm+6QJXXpXzdGVlOTEvV/6SDt+koNyLZwxe7sORh7FI= github.com/go-zeromq/zmq4 v0.4.0/go.mod h1:Sm+6QJXXpXzdGVlOTEvV/6SDt+koNyLZwxe7sORh7FI=
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg= github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/google/open-location-code/go v0.0.0-20190603181809-cf814bded323 h1:s+TV4ZPsmXNvFxr9gzRTOlqf7DT862ieiOGRWA9M3oM= github.com/google/open-location-code/go v0.0.0-20190603181809-cf814bded323 h1:s+TV4ZPsmXNvFxr9gzRTOlqf7DT862ieiOGRWA9M3oM=
github.com/google/open-location-code/go v0.0.0-20190603181809-cf814bded323/go.mod h1:eJfRN6aj+kR/rnua/rw9jAgYhqoMHldQkdTi+sePRKk= github.com/google/open-location-code/go v0.0.0-20190603181809-cf814bded323/go.mod h1:eJfRN6aj+kR/rnua/rw9jAgYhqoMHldQkdTi+sePRKk=
github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542/go.mod h1:Ow0tF8D4Kplbc8s8sSb3V2oUCygFHVp8gC3Dn6U4MNI=
github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
github.com/iotaledger/iota.go v1.0.0-beta.6 h1:KpYLldGNENbalmGDsX2Rw3kVA2Gu6z4eJIbRfuM6A1c=
github.com/iotaledger/iota.go v1.0.0-beta.6/go.mod h1:3oE7biGf+UbsMlOzUINTMXhQLEgYgEqDIYHJAst2WsA=
github.com/labstack/echo v3.3.10+incompatible h1:pGRcYk231ExFAyoAjAfD85kQzRJCRI8bbnE7CX5OEgg= github.com/labstack/echo v3.3.10+incompatible h1:pGRcYk231ExFAyoAjAfD85kQzRJCRI8bbnE7CX5OEgg=
github.com/labstack/echo v3.3.10+incompatible/go.mod h1:0INS7j/VjnFxD4E2wkz67b8cVwCLbBmJyDaka6Cmk1s= github.com/labstack/echo v3.3.10+incompatible/go.mod h1:0INS7j/VjnFxD4E2wkz67b8cVwCLbBmJyDaka6Cmk1s=
github.com/labstack/gommon v0.2.9 h1:heVeuAYtevIQVYkGj6A41dtfT91LrvFG220lavpWhrU= github.com/labstack/gommon v0.2.9 h1:heVeuAYtevIQVYkGj6A41dtfT91LrvFG220lavpWhrU=
...@@ -38,6 +52,12 @@ github.com/mattn/go-isatty v0.0.8 h1:HLtExJ+uU2HOZ+wI0Tt5DtUDrx8yhUqDcp7fYERX4CE ...@@ -38,6 +52,12 @@ github.com/mattn/go-isatty v0.0.8 h1:HLtExJ+uU2HOZ+wI0Tt5DtUDrx8yhUqDcp7fYERX4CE
github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
github.com/mattn/go-runewidth v0.0.4 h1:2BvfKmzob6Bmd4YsL0zygOqfdFnK7GR4QL06Do4/p7Y= github.com/mattn/go-runewidth v0.0.4 h1:2BvfKmzob6Bmd4YsL0zygOqfdFnK7GR4QL06Do4/p7Y=
github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32/go.mod h1:9wM+0iRr9ahx58uYLpLIr5fm8diHn0JbqRycJi6w0Ms=
github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.8.0 h1:VkHVNpR4iVnU8XQR6DBm8BqYjN7CRzw+xKUbVVbbW9w=
github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/gomega v1.5.0 h1:izbySO9zDPmjJ8rDjLvkA2zJHIo+HkYXHnf7eN7SSyo=
github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
...@@ -47,6 +67,7 @@ github.com/rivo/tview v0.0.0-20190609162513-b62197ade412 h1:muOFMct2jVhlSw9S3MRr ...@@ -47,6 +67,7 @@ github.com/rivo/tview v0.0.0-20190609162513-b62197ade412 h1:muOFMct2jVhlSw9S3MRr
github.com/rivo/tview v0.0.0-20190609162513-b62197ade412/go.mod h1:+rKjP5+h9HMwWRpAfhIkkQ9KE3m3Nz5rwn7YtUpwgqk= github.com/rivo/tview v0.0.0-20190609162513-b62197ade412/go.mod h1:+rKjP5+h9HMwWRpAfhIkkQ9KE3m3Nz5rwn7YtUpwgqk=
github.com/rivo/uniseg v0.0.0-20190513083848-b9f5b9457d44 h1:XKCbzPvK4/BbMXoMJOkYP2ANxiAEO0HM1xn6psSbXxY= github.com/rivo/uniseg v0.0.0-20190513083848-b9f5b9457d44 h1:XKCbzPvK4/BbMXoMJOkYP2ANxiAEO0HM1xn6psSbXxY=
github.com/rivo/uniseg v0.0.0-20190513083848-b9f5b9457d44/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.0.0-20190513083848-b9f5b9457d44/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
...@@ -55,22 +76,39 @@ github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6Kllzaw ...@@ -55,22 +76,39 @@ github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6Kllzaw
github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
github.com/valyala/fasttemplate v1.0.1 h1:tY9CJiPnMXf1ERmG2EyK7gNUd+c6RKGD0IfU8WdUSz8= github.com/valyala/fasttemplate v1.0.1 h1:tY9CJiPnMXf1ERmG2EyK7gNUd+c6RKGD0IfU8WdUSz8=
github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8= github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c/go.mod h1:lB8K/P019DLNhemzwFU4jHLhdvlE6uDZjXFejJXr49I=
github.com/xdg/stringprep v1.0.0/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y=
github.com/zeromq/goczmq v4.1.0+incompatible h1:cGVQaU6kIwwrGso0Pgbl84tzAz/h7FJ3wYQjSonjFFc= github.com/zeromq/goczmq v4.1.0+incompatible h1:cGVQaU6kIwwrGso0Pgbl84tzAz/h7FJ3wYQjSonjFFc=
github.com/zeromq/goczmq v4.1.0+incompatible/go.mod h1:1uZybAJoSRCvZMH2rZxEwWBSmC4T7CB/xQOfChwPEzg= github.com/zeromq/goczmq v4.1.0+incompatible/go.mod h1:1uZybAJoSRCvZMH2rZxEwWBSmC4T7CB/xQOfChwPEzg=
go.mongodb.org/mongo-driver v1.0.0/go.mod h1:u7ryQJ+DOzQmeO7zB6MHyr8jkEQvC8vH7qLUO4lqsUM=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20190404164418-38d8ce5564a5/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5 h1:58fnuSXlxZmFdJyvtTFVmVhcMLU6v5fEb/ok4wyqtNU= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5 h1:58fnuSXlxZmFdJyvtTFVmVhcMLU6v5fEb/ok4wyqtNU=
golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/net v0.0.0-20180629035331-4cb1c02c05b0/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180629035331-4cb1c02c05b0/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190611141213-3f473d35a33a h1:+KkCgOMgnKSgenxTBoiwkMqTiouMIy/3o8RLdmSbGoY= golang.org/x/net v0.0.0-20190611141213-3f473d35a33a h1:+KkCgOMgnKSgenxTBoiwkMqTiouMIy/3o8RLdmSbGoY=
golang.org/x/net v0.0.0-20190611141213-3f473d35a33a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190611141213-3f473d35a33a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6 h1:bjcUS9ztw9kFmmIxJInhon/0Is3p+EHBKNgquIzo1OI=
golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI= golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190602015325-4c4f7f33c9ed h1:uPxWBzB3+mlnjy9W58qY1j/cjyFjutgw/Vhan2zLy/A= golang.org/x/sys v0.0.0-20190602015325-4c4f7f33c9ed h1:uPxWBzB3+mlnjy9W58qY1j/cjyFjutgw/Vhan2zLy/A=
golang.org/x/sys v0.0.0-20190602015325-4c4f7f33c9ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190602015325-4c4f7f33c9ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
gopkg.in/h2non/gock.v1 v1.0.14/go.mod h1:sX4zAkdYX1TRGJ2JY156cFspQn4yRWn6p9EMdODlynE=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
...@@ -6,11 +6,12 @@ import ( ...@@ -6,11 +6,12 @@ import (
"time" "time"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/goshimmer/packages/ternary"
"github.com/iotaledger/iota.go/trinary"
) )
type HashRequest struct { type HashRequest struct {
input ternary.Trits input trinary.Trits
output chan ternary.Trits output chan trinary.Trits
} }
type BatchHasher struct { type BatchHasher struct {
...@@ -94,7 +95,7 @@ func (this *BatchHasher) processHashes(collectedHashRequests []HashRequest) { ...@@ -94,7 +95,7 @@ func (this *BatchHasher) processHashes(collectedHashRequests []HashRequest) {
close(hashRequest.output) close(hashRequest.output)
} }
} else { } else {
var resp = make(ternary.Trits, this.hashLength) var resp = make(trinary.Trits, this.hashLength)
curl := NewCurl(this.hashLength, this.rounds) curl := NewCurl(this.hashLength, this.rounds)
curl.Absorb(collectedHashRequests[0].input, 0, len(collectedHashRequests[0].input)) curl.Absorb(collectedHashRequests[0].input, 0, len(collectedHashRequests[0].input))
...@@ -105,10 +106,10 @@ func (this *BatchHasher) processHashes(collectedHashRequests []HashRequest) { ...@@ -105,10 +106,10 @@ func (this *BatchHasher) processHashes(collectedHashRequests []HashRequest) {
} }
} }
func (this *BatchHasher) Hash(trits ternary.Trits) chan ternary.Trits { func (this *BatchHasher) Hash(trits trinary.Trits) chan trinary.Trits {
hashRequest := HashRequest{ hashRequest := HashRequest{
input: trits, input: trits,
output: make(chan ternary.Trits, 1), output: make(chan trinary.Trits, 1),
} }
this.hashRequests <- hashRequest this.hashRequests <- hashRequest
......
...@@ -3,7 +3,8 @@ package curl ...@@ -3,7 +3,8 @@ package curl
import "github.com/iotaledger/goshimmer/packages/ternary" import "github.com/iotaledger/goshimmer/packages/ternary"
const ( const (
HIGH_LONG_BITS = 0xFFFFFFFFFFFFFFFF HIGH_LONG_BITS = 0xFFFFFFFFFFFFFFFF
NUMBER_OF_TRITS_IN_A_TRYTE = 3
) )
type BCTCurl struct { type BCTCurl struct {
...@@ -18,10 +19,10 @@ func NewBCTCurl(hashLength int, numberOfRounds int) *BCTCurl { ...@@ -18,10 +19,10 @@ func NewBCTCurl(hashLength int, numberOfRounds int) *BCTCurl {
this := &BCTCurl{ this := &BCTCurl{
hashLength: hashLength, hashLength: hashLength,
numberOfRounds: numberOfRounds, numberOfRounds: numberOfRounds,
stateLength: ternary.NUMBER_OF_TRITS_IN_A_TRYTE * hashLength, stateLength: NUMBER_OF_TRITS_IN_A_TRYTE * hashLength,
state: ternary.BCTrits{ state: ternary.BCTrits{
Lo: make([]uint, ternary.NUMBER_OF_TRITS_IN_A_TRYTE*hashLength), Lo: make([]uint, NUMBER_OF_TRITS_IN_A_TRYTE*hashLength),
Hi: make([]uint, ternary.NUMBER_OF_TRITS_IN_A_TRYTE*hashLength), Hi: make([]uint, NUMBER_OF_TRITS_IN_A_TRYTE*hashLength),
}, },
cTransform: nil, cTransform: nil,
} }
......
...@@ -3,16 +3,16 @@ package curl ...@@ -3,16 +3,16 @@ package curl
import ( import (
"math" "math"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
) )
const ( const (
HASH_LENGTH = 243 HASH_LENGTH = 243
STATE_LENGTH = ternary.NUMBER_OF_TRITS_IN_A_TRYTE * HASH_LENGTH STATE_LENGTH = 3 * HASH_LENGTH
) )
var ( var (
TRUTH_TABLE = ternary.Trits{1, 0, -1, 2, 1, -1, 0, 2, -1, 1, 0} TRUTH_TABLE = trinary.Trits{1, 0, -1, 2, 1, -1, 0, 2, -1, 1, 0}
) )
type Hash interface { type Hash interface {
...@@ -25,7 +25,7 @@ type Hash interface { ...@@ -25,7 +25,7 @@ type Hash interface {
type Curl struct { type Curl struct {
Hash Hash
state ternary.Trits state trinary.Trits
hashLength int hashLength int
rounds int rounds int
} }
...@@ -45,12 +45,12 @@ func (curl *Curl) Initialize() { ...@@ -45,12 +45,12 @@ func (curl *Curl) Initialize() {
curl.InitializeCurl(nil, 0, curl.rounds) curl.InitializeCurl(nil, 0, curl.rounds)
} }
func (curl *Curl) InitializeCurl(trits ternary.Trits, length int, rounds int) { func (curl *Curl) InitializeCurl(trits trinary.Trits, length int, rounds int) {
curl.rounds = rounds curl.rounds = rounds
if trits != nil { if trits != nil {
curl.state = trits curl.state = trits
} else { } else {
curl.state = make(ternary.Trits, STATE_LENGTH) curl.state = make(trinary.Trits, STATE_LENGTH)
} }
} }
...@@ -58,7 +58,7 @@ func (curl *Curl) Reset() { ...@@ -58,7 +58,7 @@ func (curl *Curl) Reset() {
curl.InitializeCurl(nil, 0, curl.rounds) curl.InitializeCurl(nil, 0, curl.rounds)
} }
func (curl *Curl) Absorb(trits ternary.Trits, offset int, length int) { func (curl *Curl) Absorb(trits trinary.Trits, offset int, length int) {
for { for {
limit := int(math.Min(HASH_LENGTH, float64(length))) limit := int(math.Min(HASH_LENGTH, float64(length)))
copy(curl.state, trits[offset:offset+limit]) copy(curl.state, trits[offset:offset+limit])
...@@ -71,7 +71,7 @@ func (curl *Curl) Absorb(trits ternary.Trits, offset int, length int) { ...@@ -71,7 +71,7 @@ func (curl *Curl) Absorb(trits ternary.Trits, offset int, length int) {
} }
} }
func (curl *Curl) Squeeze(resp ternary.Trits, offset int, length int) ternary.Trits { func (curl *Curl) Squeeze(resp trinary.Trits, offset int, length int) trinary.Trits {
for { for {
limit := int(math.Min(HASH_LENGTH, float64(length))) limit := int(math.Min(HASH_LENGTH, float64(length)))
copy(resp[offset:offset+limit], curl.state) copy(resp[offset:offset+limit], curl.state)
...@@ -88,7 +88,7 @@ func (curl *Curl) Squeeze(resp ternary.Trits, offset int, length int) ternary.Tr ...@@ -88,7 +88,7 @@ func (curl *Curl) Squeeze(resp ternary.Trits, offset int, length int) ternary.Tr
func (curl *Curl) Transform() { func (curl *Curl) Transform() {
var index = 0 var index = 0
for round := 0; round < curl.rounds; round++ { for round := 0; round < curl.rounds; round++ {
stateCopy := make(ternary.Trits, STATE_LENGTH) stateCopy := make(trinary.Trits, STATE_LENGTH)
copy(stateCopy, curl.state) copy(stateCopy, curl.state)
for i := 0; i < STATE_LENGTH; i++ { for i := 0; i < STATE_LENGTH; i++ {
incr := 364 incr := 364
......
...@@ -4,12 +4,12 @@ import ( ...@@ -4,12 +4,12 @@ import (
"math" "math"
olc "github.com/google/open-location-code/go" olc "github.com/google/open-location-code/go"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
) )
type Area struct { type Area struct {
olc.CodeArea olc.CodeArea
IACCode ternary.Trytes IACCode trinary.Trytes
OLCCode string OLCCode string
} }
......
...@@ -3,10 +3,10 @@ package iac ...@@ -3,10 +3,10 @@ package iac
import ( import (
olc "github.com/google/open-location-code/go" olc "github.com/google/open-location-code/go"
"github.com/iotaledger/goshimmer/packages/errors" "github.com/iotaledger/goshimmer/packages/errors"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
) )
func Decode(trytes ternary.Trytes) (result *Area, err errors.IdentifiableError) { func Decode(trytes trinary.Trytes) (result *Area, err errors.IdentifiableError) {
if olcCode, conversionErr := OLCCodeFromTrytes(trytes); conversionErr != nil { if olcCode, conversionErr := OLCCodeFromTrytes(trytes); conversionErr != nil {
err = conversionErr err = conversionErr
} else { } else {
......
...@@ -2,7 +2,7 @@ package iac ...@@ -2,7 +2,7 @@ package iac
import ( import (
"github.com/iotaledger/goshimmer/packages/errors" "github.com/iotaledger/goshimmer/packages/errors"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
) )
var ( var (
...@@ -31,10 +31,10 @@ func init() { ...@@ -31,10 +31,10 @@ func init() {
IAC_TO_OLC_MAP[IAC_PADDING] = OLC_PADDING IAC_TO_OLC_MAP[IAC_PADDING] = OLC_PADDING
} }
func TrytesFromOLCCode(code string) (result ternary.Trytes, err errors.IdentifiableError) { func TrytesFromOLCCode(code string) (result trinary.Trytes, err errors.IdentifiableError) {
for _, char := range code { for _, char := range code {
if translatedChar, exists := OLC_TO_IAC_MAP[char]; exists { if translatedChar, exists := OLC_TO_IAC_MAP[char]; exists {
result += ternary.Trytes(translatedChar) result += trinary.Trytes(translatedChar)
} else { } else {
err = ErrConversionFailed.Derive("invalid character in input") err = ErrConversionFailed.Derive("invalid character in input")
} }
...@@ -43,7 +43,7 @@ func TrytesFromOLCCode(code string) (result ternary.Trytes, err errors.Identifia ...@@ -43,7 +43,7 @@ func TrytesFromOLCCode(code string) (result ternary.Trytes, err errors.Identifia
return return
} }
func OLCCodeFromTrytes(trytes ternary.Trytes) (result string, err errors.IdentifiableError) { func OLCCodeFromTrytes(trytes trinary.Trytes) (result string, err errors.IdentifiableError) {
for _, char := range trytes { for _, char := range trytes {
if translatedChar, exists := IAC_TO_OLC_MAP[char]; exists { if translatedChar, exists := IAC_TO_OLC_MAP[char]; exists {
result += string(translatedChar) result += string(translatedChar)
......
...@@ -6,40 +6,41 @@ import ( ...@@ -6,40 +6,41 @@ import (
"sync" "sync"
"github.com/iotaledger/goshimmer/packages/errors" "github.com/iotaledger/goshimmer/packages/errors"
"github.com/iotaledger/goshimmer/packages/ternary"
"github.com/iotaledger/goshimmer/packages/typeutils" "github.com/iotaledger/goshimmer/packages/typeutils"
"github.com/iotaledger/goshimmer/packages/unsafeconvert"
"github.com/iotaledger/iota.go/trinary"
) )
type Approvers struct { type Approvers struct {
hash ternary.Trytes hash trinary.Trytes
hashes map[ternary.Trytes]bool hashes map[trinary.Trytes]bool
hashesMutex sync.RWMutex hashesMutex sync.RWMutex
modified bool modified bool
} }
func New(hash ternary.Trytes) *Approvers { func New(hash trinary.Trytes) *Approvers {
return &Approvers{ return &Approvers{
hash: hash, hash: hash,
hashes: make(map[ternary.Trytes]bool), hashes: make(map[trinary.Trytes]bool),
modified: false, modified: false,
} }
} }
// region public methods with locking ////////////////////////////////////////////////////////////////////////////////// // region public methods with locking //////////////////////////////////////////////////////////////////////////////////
func (approvers *Approvers) Add(transactionHash ternary.Trytes) { func (approvers *Approvers) Add(transactionHash trinary.Trytes) {
approvers.hashesMutex.Lock() approvers.hashesMutex.Lock()
approvers.add(transactionHash) approvers.add(transactionHash)
approvers.hashesMutex.Unlock() approvers.hashesMutex.Unlock()
} }
func (approvers *Approvers) Remove(approverHash ternary.Trytes) { func (approvers *Approvers) Remove(approverHash trinary.Trytes) {
approvers.hashesMutex.Lock() approvers.hashesMutex.Lock()
approvers.remove(approverHash) approvers.remove(approverHash)
approvers.hashesMutex.Unlock() approvers.hashesMutex.Unlock()
} }
func (approvers *Approvers) GetHashes() (result []ternary.Trytes) { func (approvers *Approvers) GetHashes() (result []trinary.Trytes) {
approvers.hashesMutex.RLock() approvers.hashesMutex.RLock()
result = approvers.getHashes() result = approvers.getHashes()
approvers.hashesMutex.RUnlock() approvers.hashesMutex.RUnlock()
...@@ -47,7 +48,7 @@ func (approvers *Approvers) GetHashes() (result []ternary.Trytes) { ...@@ -47,7 +48,7 @@ func (approvers *Approvers) GetHashes() (result []ternary.Trytes) {
return return
} }
func (approvers *Approvers) GetHash() (result ternary.Trytes) { func (approvers *Approvers) GetHash() (result trinary.Trytes) {
approvers.hashesMutex.RLock() approvers.hashesMutex.RLock()
result = approvers.hash result = approvers.hash
approvers.hashesMutex.RUnlock() approvers.hashesMutex.RUnlock()
...@@ -69,14 +70,14 @@ func (approvers *Approvers) Marshal() (result []byte) { ...@@ -69,14 +70,14 @@ func (approvers *Approvers) Marshal() (result []byte) {
binary.BigEndian.PutUint64(result[MARSHALED_APPROVERS_HASHES_COUNT_START:MARSHALED_APPROVERS_HASHES_COUNT_END], uint64(len(approvers.hashes))) binary.BigEndian.PutUint64(result[MARSHALED_APPROVERS_HASHES_COUNT_START:MARSHALED_APPROVERS_HASHES_COUNT_END], uint64(len(approvers.hashes)))
copy(result[MARSHALED_APPROVERS_HASH_START:MARSHALED_APPROVERS_HASH_END], approvers.hash.CastToBytes()) copy(result[MARSHALED_APPROVERS_HASH_START:MARSHALED_APPROVERS_HASH_END], unsafeconvert.StringToBytes(approvers.hash))
i := 0 i := 0
for hash := range approvers.hashes { for hash := range approvers.hashes {
var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(MARSHALED_APPROVERS_HASH_SIZE) var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(MARSHALED_APPROVERS_HASH_SIZE)
var HASH_END = HASH_START + MARSHALED_APPROVERS_HASH_SIZE var HASH_END = HASH_START + MARSHALED_APPROVERS_HASH_SIZE
copy(result[HASH_START:HASH_END], hash.CastToBytes()) copy(result[HASH_START:HASH_END], unsafeconvert.StringToBytes(hash))
i++ i++
} }
...@@ -101,13 +102,13 @@ func (approvers *Approvers) Unmarshal(data []byte) (err errors.IdentifiableError ...@@ -101,13 +102,13 @@ func (approvers *Approvers) Unmarshal(data []byte) (err errors.IdentifiableError
approvers.hashesMutex.Lock() approvers.hashesMutex.Lock()
approvers.hash = ternary.Trytes(typeutils.BytesToString(data[MARSHALED_APPROVERS_HASH_START:MARSHALED_APPROVERS_HASH_END])) approvers.hash = trinary.Trytes(typeutils.BytesToString(data[MARSHALED_APPROVERS_HASH_START:MARSHALED_APPROVERS_HASH_END]))
approvers.hashes = make(map[ternary.Trytes]bool, hashesCount) approvers.hashes = make(map[trinary.Trytes]bool, hashesCount)
for i := uint64(0); i < hashesCount; i++ { for i := uint64(0); i < hashesCount; i++ {
var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(MARSHALED_APPROVERS_HASH_SIZE) var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(MARSHALED_APPROVERS_HASH_SIZE)
var HASH_END = HASH_START + MARSHALED_APPROVERS_HASH_SIZE var HASH_END = HASH_START + MARSHALED_APPROVERS_HASH_SIZE
approvers.hashes[ternary.Trytes(typeutils.BytesToString(data[HASH_START:HASH_END]))] = true approvers.hashes[trinary.Trytes(typeutils.BytesToString(data[HASH_START:HASH_END]))] = true
} }
approvers.hashesMutex.Unlock() approvers.hashesMutex.Unlock()
...@@ -119,22 +120,22 @@ func (approvers *Approvers) Unmarshal(data []byte) (err errors.IdentifiableError ...@@ -119,22 +120,22 @@ func (approvers *Approvers) Unmarshal(data []byte) (err errors.IdentifiableError
// region private methods without locking ////////////////////////////////////////////////////////////////////////////// // region private methods without locking //////////////////////////////////////////////////////////////////////////////
func (approvers *Approvers) add(transactionHash ternary.Trytes) { func (approvers *Approvers) add(transactionHash trinary.Trytes) {
if _, exists := approvers.hashes[transactionHash]; !exists { if _, exists := approvers.hashes[transactionHash]; !exists {
approvers.hashes[transactionHash] = true approvers.hashes[transactionHash] = true
approvers.modified = true approvers.modified = true
} }
} }
func (approvers *Approvers) remove(approverHash ternary.Trytes) { func (approvers *Approvers) remove(approverHash trinary.Trytes) {
if _, exists := approvers.hashes[approverHash]; exists { if _, exists := approvers.hashes[approverHash]; exists {
delete(approvers.hashes, approverHash) delete(approvers.hashes, approverHash)
approvers.modified = true approvers.modified = true
} }
} }
func (approvers *Approvers) getHashes() (result []ternary.Trytes) { func (approvers *Approvers) getHashes() (result []trinary.Trytes) {
result = make([]ternary.Trytes, len(approvers.hashes)) result = make([]trinary.Trytes, len(approvers.hashes))
counter := 0 counter := 0
for hash := range approvers.hashes { for hash := range approvers.hashes {
......
...@@ -4,13 +4,13 @@ import ( ...@@ -4,13 +4,13 @@ import (
"fmt" "fmt"
"testing" "testing"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
"github.com/magiconair/properties/assert" "github.com/magiconair/properties/assert"
) )
func TestApprovers_SettersGetters(t *testing.T) { func TestApprovers_SettersGetters(t *testing.T) {
hashA := ternary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F") hashA := trinary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
hashB := ternary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F") hashB := trinary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
approversTest := New(hashA) approversTest := New(hashA)
approversTest.Add(hashB) approversTest.Add(hashB)
...@@ -19,8 +19,8 @@ func TestApprovers_SettersGetters(t *testing.T) { ...@@ -19,8 +19,8 @@ func TestApprovers_SettersGetters(t *testing.T) {
} }
func TestApprovers_MarshalUnmarshal(t *testing.T) { func TestApprovers_MarshalUnmarshal(t *testing.T) {
hashA := ternary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F") hashA := trinary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
hashB := ternary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F") hashB := trinary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
approversTest := New(hashA) approversTest := New(hashA)
approversTest.Add(hashB) approversTest.Add(hashB)
......
...@@ -9,24 +9,24 @@ import ( ...@@ -9,24 +9,24 @@ import (
"github.com/iotaledger/goshimmer/packages/bitutils" "github.com/iotaledger/goshimmer/packages/bitutils"
"github.com/iotaledger/goshimmer/packages/errors" "github.com/iotaledger/goshimmer/packages/errors"
"github.com/iotaledger/goshimmer/packages/typeutils" "github.com/iotaledger/goshimmer/packages/typeutils"
"github.com/iotaledger/goshimmer/packages/unsafeconvert"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
) )
type Bundle struct { type Bundle struct {
hash ternary.Trytes hash trinary.Trytes
hashMutex sync.RWMutex hashMutex sync.RWMutex
transactionHashes []ternary.Trytes transactionHashes []trinary.Trytes
transactionHashesMutex sync.RWMutex transactionHashesMutex sync.RWMutex
isValueBundle bool isValueBundle bool
isValueBundleMutex sync.RWMutex isValueBundleMutex sync.RWMutex
bundleEssenceHash ternary.Trytes bundleEssenceHash trinary.Trytes
bundleEssenceHashMutex sync.RWMutex bundleEssenceHashMutex sync.RWMutex
modified bool modified bool
modifiedMutex sync.RWMutex modifiedMutex sync.RWMutex
} }
func New(headTransactionHash ternary.Trytes) (result *Bundle) { func New(headTransactionHash trinary.Trytes) (result *Bundle) {
result = &Bundle{ result = &Bundle{
hash: headTransactionHash, hash: headTransactionHash,
} }
...@@ -34,7 +34,7 @@ func New(headTransactionHash ternary.Trytes) (result *Bundle) { ...@@ -34,7 +34,7 @@ func New(headTransactionHash ternary.Trytes) (result *Bundle) {
return return
} }
func (bundle *Bundle) GetHash() (result ternary.Trytes) { func (bundle *Bundle) GetHash() (result trinary.Trytes) {
bundle.hashMutex.RLock() bundle.hashMutex.RLock()
result = bundle.hash result = bundle.hash
bundle.hashMutex.RUnlock() bundle.hashMutex.RUnlock()
...@@ -42,13 +42,13 @@ func (bundle *Bundle) GetHash() (result ternary.Trytes) { ...@@ -42,13 +42,13 @@ func (bundle *Bundle) GetHash() (result ternary.Trytes) {
return return
} }
func (bundle *Bundle) SetHash(hash ternary.Trytes) { func (bundle *Bundle) SetHash(hash trinary.Trytes) {
bundle.hashMutex.Lock() bundle.hashMutex.Lock()
bundle.hash = hash bundle.hash = hash
bundle.hashMutex.Unlock() bundle.hashMutex.Unlock()
} }
func (bundle *Bundle) GetTransactionHashes() (result []ternary.Trytes) { func (bundle *Bundle) GetTransactionHashes() (result []trinary.Trytes) {
bundle.bundleEssenceHashMutex.RLock() bundle.bundleEssenceHashMutex.RLock()
result = bundle.transactionHashes result = bundle.transactionHashes
bundle.bundleEssenceHashMutex.RUnlock() bundle.bundleEssenceHashMutex.RUnlock()
...@@ -56,7 +56,7 @@ func (bundle *Bundle) GetTransactionHashes() (result []ternary.Trytes) { ...@@ -56,7 +56,7 @@ func (bundle *Bundle) GetTransactionHashes() (result []ternary.Trytes) {
return return
} }
func (bundle *Bundle) SetTransactionHashes(transactionHashes []ternary.Trytes) { func (bundle *Bundle) SetTransactionHashes(transactionHashes []trinary.Trytes) {
bundle.transactionHashesMutex.Lock() bundle.transactionHashesMutex.Lock()
bundle.transactionHashes = transactionHashes bundle.transactionHashes = transactionHashes
bundle.transactionHashesMutex.Unlock() bundle.transactionHashesMutex.Unlock()
...@@ -76,7 +76,7 @@ func (bundle *Bundle) SetValueBundle(valueBundle bool) { ...@@ -76,7 +76,7 @@ func (bundle *Bundle) SetValueBundle(valueBundle bool) {
bundle.isValueBundleMutex.Unlock() bundle.isValueBundleMutex.Unlock()
} }
func (bundle *Bundle) GetBundleEssenceHash() (result ternary.Trytes) { func (bundle *Bundle) GetBundleEssenceHash() (result trinary.Trytes) {
bundle.bundleEssenceHashMutex.RLock() bundle.bundleEssenceHashMutex.RLock()
result = bundle.bundleEssenceHash result = bundle.bundleEssenceHash
bundle.bundleEssenceHashMutex.RUnlock() bundle.bundleEssenceHashMutex.RUnlock()
...@@ -84,7 +84,7 @@ func (bundle *Bundle) GetBundleEssenceHash() (result ternary.Trytes) { ...@@ -84,7 +84,7 @@ func (bundle *Bundle) GetBundleEssenceHash() (result ternary.Trytes) {
return return
} }
func (bundle *Bundle) SetBundleEssenceHash(bundleEssenceHash ternary.Trytes) { func (bundle *Bundle) SetBundleEssenceHash(bundleEssenceHash trinary.Trytes) {
bundle.bundleEssenceHashMutex.Lock() bundle.bundleEssenceHashMutex.Lock()
bundle.bundleEssenceHash = bundleEssenceHash bundle.bundleEssenceHash = bundleEssenceHash
bundle.bundleEssenceHashMutex.Unlock() bundle.bundleEssenceHashMutex.Unlock()
...@@ -114,8 +114,8 @@ func (bundle *Bundle) Marshal() (result []byte) { ...@@ -114,8 +114,8 @@ func (bundle *Bundle) Marshal() (result []byte) {
binary.BigEndian.PutUint64(result[MARSHALED_TRANSACTIONS_COUNT_START:MARSHALED_TRANSACTIONS_COUNT_END], uint64(len(bundle.transactionHashes))) binary.BigEndian.PutUint64(result[MARSHALED_TRANSACTIONS_COUNT_START:MARSHALED_TRANSACTIONS_COUNT_END], uint64(len(bundle.transactionHashes)))
copy(result[MARSHALED_HASH_START:MARSHALED_HASH_END], bundle.hash.CastToBytes()) copy(result[MARSHALED_HASH_START:MARSHALED_HASH_END], unsafeconvert.StringToBytes(bundle.hash))
copy(result[MARSHALED_BUNDLE_ESSENCE_HASH_START:MARSHALED_BUNDLE_ESSENCE_HASH_END], bundle.bundleEssenceHash.CastToBytes()) copy(result[MARSHALED_BUNDLE_ESSENCE_HASH_START:MARSHALED_BUNDLE_ESSENCE_HASH_END], unsafeconvert.StringToBytes(bundle.bundleEssenceHash))
var flags bitutils.BitMask var flags bitutils.BitMask
if bundle.isValueBundle { if bundle.isValueBundle {
...@@ -128,7 +128,7 @@ func (bundle *Bundle) Marshal() (result []byte) { ...@@ -128,7 +128,7 @@ func (bundle *Bundle) Marshal() (result []byte) {
var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(MARSHALED_TRANSACTION_HASH_SIZE) var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(MARSHALED_TRANSACTION_HASH_SIZE)
var HASH_END = HASH_START + MARSHALED_TRANSACTION_HASH_SIZE var HASH_END = HASH_START + MARSHALED_TRANSACTION_HASH_SIZE
copy(result[HASH_START:HASH_END], hash.CastToBytes()) copy(result[HASH_START:HASH_END], unsafeconvert.StringToBytes(hash))
i++ i++
} }
...@@ -159,20 +159,20 @@ func (bundle *Bundle) Unmarshal(data []byte) (err errors.IdentifiableError) { ...@@ -159,20 +159,20 @@ func (bundle *Bundle) Unmarshal(data []byte) (err errors.IdentifiableError) {
bundle.isValueBundleMutex.Lock() bundle.isValueBundleMutex.Lock()
bundle.transactionHashesMutex.Lock() bundle.transactionHashesMutex.Lock()
bundle.hash = ternary.Trytes(typeutils.BytesToString(data[MARSHALED_HASH_START:MARSHALED_HASH_END])) bundle.hash = trinary.Trytes(typeutils.BytesToString(data[MARSHALED_HASH_START:MARSHALED_HASH_END]))
bundle.bundleEssenceHash = ternary.Trytes(typeutils.BytesToString(data[MARSHALED_BUNDLE_ESSENCE_HASH_START:MARSHALED_BUNDLE_ESSENCE_HASH_END])) bundle.bundleEssenceHash = trinary.Trytes(typeutils.BytesToString(data[MARSHALED_BUNDLE_ESSENCE_HASH_START:MARSHALED_BUNDLE_ESSENCE_HASH_END]))
flags := bitutils.BitMask(data[MARSHALED_FLAGS_START]) flags := bitutils.BitMask(data[MARSHALED_FLAGS_START])
if flags.HasFlag(0) { if flags.HasFlag(0) {
bundle.isValueBundle = true bundle.isValueBundle = true
} }
bundle.transactionHashes = make([]ternary.Trytes, hashesCount) bundle.transactionHashes = make([]trinary.Trytes, hashesCount)
for i := uint64(0); i < hashesCount; i++ { for i := uint64(0); i < hashesCount; i++ {
var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(MARSHALED_TRANSACTION_HASH_SIZE) var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(MARSHALED_TRANSACTION_HASH_SIZE)
var HASH_END = HASH_START + MARSHALED_TRANSACTION_HASH_SIZE var HASH_END = HASH_START + MARSHALED_TRANSACTION_HASH_SIZE
bundle.transactionHashes[i] = ternary.Trytes(typeutils.BytesToString(data[HASH_START:HASH_END])) bundle.transactionHashes[i] = trinary.Trytes(typeutils.BytesToString(data[HASH_START:HASH_END]))
} }
bundle.transactionHashesMutex.Unlock() bundle.transactionHashesMutex.Unlock()
......
...@@ -3,16 +3,16 @@ package bundle ...@@ -3,16 +3,16 @@ package bundle
import ( import (
"testing" "testing"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
"github.com/magiconair/properties/assert" "github.com/magiconair/properties/assert"
) )
func TestBundle_SettersGetters(t *testing.T) { func TestBundle_SettersGetters(t *testing.T) {
bundleHash := ternary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F") bundleHash := trinary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
bundleEssenceHash := ternary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F") bundleEssenceHash := trinary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
transactions := []ternary.Trytes{ transactions := []trinary.Trytes{
bundleHash, bundleHash,
ternary.Trytes("C9999999999999999999999999999999999999999999999999999999999999999999999999999999F"), trinary.Trytes("C9999999999999999999999999999999999999999999999999999999999999999999999999999999F"),
} }
testBundle := New(bundleHash) testBundle := New(bundleHash)
...@@ -29,11 +29,11 @@ func TestBundle_SettersGetters(t *testing.T) { ...@@ -29,11 +29,11 @@ func TestBundle_SettersGetters(t *testing.T) {
} }
func TestBundle_SettersGettersMarshalUnmarshal(t *testing.T) { func TestBundle_SettersGettersMarshalUnmarshal(t *testing.T) {
bundleHash := ternary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F") bundleHash := trinary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
bundleEssenceHash := ternary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F") bundleEssenceHash := trinary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
transactions := []ternary.Trytes{ transactions := []trinary.Trytes{
bundleHash, bundleHash,
ternary.Trytes("C9999999999999999999999999999999999999999999999999999999999999999999999999999999F"), trinary.Trytes("C9999999999999999999999999999999999999999999999999999999999999999999999999999999F"),
} }
testBundle := New(bundleHash) testBundle := New(bundleHash)
......
package meta_transaction package meta_transaction
import ( import (
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
) )
const ( const (
...@@ -31,5 +31,5 @@ const ( ...@@ -31,5 +31,5 @@ const (
MARSHALED_TOTAL_SIZE = DATA_END MARSHALED_TOTAL_SIZE = DATA_END
BRANCH_NULL_HASH = ternary.Trytes("999999999999999999999999999999999999999999999999999999999999999999999999999999999") BRANCH_NULL_HASH = trinary.Trytes("999999999999999999999999999999999999999999999999999999999999999999999999999999999")
) )
...@@ -4,20 +4,20 @@ import ( ...@@ -4,20 +4,20 @@ import (
"sync" "sync"
"github.com/iotaledger/goshimmer/packages/curl" "github.com/iotaledger/goshimmer/packages/curl"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
) )
type MetaTransaction struct { type MetaTransaction struct {
hash *ternary.Trytes hash *trinary.Trytes
weightMagnitude int weightMagnitude int
shardMarker *ternary.Trytes shardMarker *trinary.Trytes
trunkTransactionHash *ternary.Trytes trunkTransactionHash *trinary.Trytes
branchTransactionHash *ternary.Trytes branchTransactionHash *trinary.Trytes
head *bool head *bool
tail *bool tail *bool
transactionType *ternary.Trytes transactionType *trinary.Trytes
data ternary.Trits data trinary.Trits
modified bool modified bool
hasherMutex sync.RWMutex hasherMutex sync.RWMutex
...@@ -32,22 +32,27 @@ type MetaTransaction struct { ...@@ -32,22 +32,27 @@ type MetaTransaction struct {
bytesMutex sync.RWMutex bytesMutex sync.RWMutex
modifiedMutex sync.RWMutex modifiedMutex sync.RWMutex
trits ternary.Trits trits trinary.Trits
bytes []byte bytes []byte
} }
func New() *MetaTransaction { func New() *MetaTransaction {
return FromTrits(make(ternary.Trits, MARSHALED_TOTAL_SIZE)) return FromTrits(make(trinary.Trits, MARSHALED_TOTAL_SIZE))
} }
func FromTrits(trits ternary.Trits) *MetaTransaction { func FromTrits(trits trinary.Trits) *MetaTransaction {
return &MetaTransaction{ return &MetaTransaction{
trits: trits, trits: trits,
} }
} }
func FromBytes(bytes []byte) (result *MetaTransaction) { func FromBytes(bytes []byte) (result *MetaTransaction) {
result = FromTrits(ternary.BytesToTrits(bytes)[:MARSHALED_TOTAL_SIZE]) trits, err := trinary.BytesToTrits(bytes)
if err != nil {
panic(err)
}
result = FromTrits(trits[:MARSHALED_TOTAL_SIZE])
result.bytes = bytes result.bytes = bytes
return return
...@@ -72,7 +77,7 @@ func (this *MetaTransaction) ReHash() { ...@@ -72,7 +77,7 @@ func (this *MetaTransaction) ReHash() {
} }
// retrieves the hash of the transaction // retrieves the hash of the transaction
func (this *MetaTransaction) GetHash() (result ternary.Trytes) { func (this *MetaTransaction) GetHash() (result trinary.Trytes) {
this.hashMutex.RLock() this.hashMutex.RLock()
if this.hash == nil { if this.hash == nil {
this.hashMutex.RUnlock() this.hashMutex.RUnlock()
...@@ -116,21 +121,21 @@ func (this *MetaTransaction) GetWeightMagnitude() (result int) { ...@@ -116,21 +121,21 @@ func (this *MetaTransaction) GetWeightMagnitude() (result int) {
// hashes the transaction using curl (without locking - internal usage) // hashes the transaction using curl (without locking - internal usage)
func (this *MetaTransaction) parseHashRelatedDetails() { func (this *MetaTransaction) parseHashRelatedDetails() {
hashTrits := <-curl.CURLP81.Hash(this.trits) hashTrits := <-curl.CURLP81.Hash(this.trits)
hashTrytes := hashTrits.ToTrytes() hashTrytes := trinary.MustTritsToTrytes(hashTrits)
this.hash = &hashTrytes this.hash = &hashTrytes
this.weightMagnitude = hashTrits.TrailingZeroes() this.weightMagnitude = int(trinary.TrailingZeros(hashTrits))
} }
// getter for the shard marker (supports concurrency) // getter for the shard marker (supports concurrency)
func (this *MetaTransaction) GetShardMarker() (result ternary.Trytes) { func (this *MetaTransaction) GetShardMarker() (result trinary.Trytes) {
this.shardMarkerMutex.RLock() this.shardMarkerMutex.RLock()
if this.shardMarker == nil { if this.shardMarker == nil {
this.shardMarkerMutex.RUnlock() this.shardMarkerMutex.RUnlock()
this.shardMarkerMutex.Lock() this.shardMarkerMutex.Lock()
defer this.shardMarkerMutex.Unlock() defer this.shardMarkerMutex.Unlock()
if this.shardMarker == nil { if this.shardMarker == nil {
shardMarker := this.trits[SHARD_MARKER_OFFSET:SHARD_MARKER_END].ToTrytes() shardMarker := trinary.MustTritsToTrytes(this.trits[SHARD_MARKER_OFFSET:SHARD_MARKER_END])
this.shardMarker = &shardMarker this.shardMarker = &shardMarker
} }
...@@ -144,7 +149,7 @@ func (this *MetaTransaction) GetShardMarker() (result ternary.Trytes) { ...@@ -144,7 +149,7 @@ func (this *MetaTransaction) GetShardMarker() (result ternary.Trytes) {
} }
// setter for the shard marker (supports concurrency) // setter for the shard marker (supports concurrency)
func (this *MetaTransaction) SetShardMarker(shardMarker ternary.Trytes) bool { func (this *MetaTransaction) SetShardMarker(shardMarker trinary.Trytes) bool {
this.shardMarkerMutex.RLock() this.shardMarkerMutex.RLock()
if this.shardMarker == nil || *this.shardMarker != shardMarker { if this.shardMarker == nil || *this.shardMarker != shardMarker {
this.shardMarkerMutex.RUnlock() this.shardMarkerMutex.RUnlock()
...@@ -154,7 +159,7 @@ func (this *MetaTransaction) SetShardMarker(shardMarker ternary.Trytes) bool { ...@@ -154,7 +159,7 @@ func (this *MetaTransaction) SetShardMarker(shardMarker ternary.Trytes) bool {
this.shardMarker = &shardMarker this.shardMarker = &shardMarker
this.hasherMutex.RLock() this.hasherMutex.RLock()
copy(this.trits[SHARD_MARKER_OFFSET:SHARD_MARKER_END], shardMarker.ToTrits()[:SHARD_MARKER_SIZE]) copy(this.trits[SHARD_MARKER_OFFSET:SHARD_MARKER_END], trinary.MustTrytesToTrits(shardMarker)[:SHARD_MARKER_SIZE])
this.hasherMutex.RUnlock() this.hasherMutex.RUnlock()
this.SetModified(true) this.SetModified(true)
...@@ -170,14 +175,14 @@ func (this *MetaTransaction) SetShardMarker(shardMarker ternary.Trytes) bool { ...@@ -170,14 +175,14 @@ func (this *MetaTransaction) SetShardMarker(shardMarker ternary.Trytes) bool {
} }
// getter for the bundleHash (supports concurrency) // getter for the bundleHash (supports concurrency)
func (this *MetaTransaction) GetTrunkTransactionHash() (result ternary.Trytes) { func (this *MetaTransaction) GetTrunkTransactionHash() (result trinary.Trytes) {
this.trunkTransactionHashMutex.RLock() this.trunkTransactionHashMutex.RLock()
if this.trunkTransactionHash == nil { if this.trunkTransactionHash == nil {
this.trunkTransactionHashMutex.RUnlock() this.trunkTransactionHashMutex.RUnlock()
this.trunkTransactionHashMutex.Lock() this.trunkTransactionHashMutex.Lock()
defer this.trunkTransactionHashMutex.Unlock() defer this.trunkTransactionHashMutex.Unlock()
if this.trunkTransactionHash == nil { if this.trunkTransactionHash == nil {
trunkTransactionHash := this.trits[TRUNK_TRANSACTION_HASH_OFFSET:TRUNK_TRANSACTION_HASH_END].ToTrytes() trunkTransactionHash := trinary.MustTritsToTrytes(this.trits[TRUNK_TRANSACTION_HASH_OFFSET:TRUNK_TRANSACTION_HASH_END])
this.trunkTransactionHash = &trunkTransactionHash this.trunkTransactionHash = &trunkTransactionHash
} }
...@@ -191,7 +196,7 @@ func (this *MetaTransaction) GetTrunkTransactionHash() (result ternary.Trytes) { ...@@ -191,7 +196,7 @@ func (this *MetaTransaction) GetTrunkTransactionHash() (result ternary.Trytes) {
} }
// setter for the trunkTransactionHash (supports concurrency) // setter for the trunkTransactionHash (supports concurrency)
func (this *MetaTransaction) SetTrunkTransactionHash(trunkTransactionHash ternary.Trytes) bool { func (this *MetaTransaction) SetTrunkTransactionHash(trunkTransactionHash trinary.Trytes) bool {
this.trunkTransactionHashMutex.RLock() this.trunkTransactionHashMutex.RLock()
if this.trunkTransactionHash == nil || *this.trunkTransactionHash != trunkTransactionHash { if this.trunkTransactionHash == nil || *this.trunkTransactionHash != trunkTransactionHash {
this.trunkTransactionHashMutex.RUnlock() this.trunkTransactionHashMutex.RUnlock()
...@@ -201,7 +206,7 @@ func (this *MetaTransaction) SetTrunkTransactionHash(trunkTransactionHash ternar ...@@ -201,7 +206,7 @@ func (this *MetaTransaction) SetTrunkTransactionHash(trunkTransactionHash ternar
this.trunkTransactionHash = &trunkTransactionHash this.trunkTransactionHash = &trunkTransactionHash
this.hasherMutex.RLock() this.hasherMutex.RLock()
copy(this.trits[TRUNK_TRANSACTION_HASH_OFFSET:TRUNK_TRANSACTION_HASH_END], trunkTransactionHash.ToTrits()[:TRUNK_TRANSACTION_HASH_SIZE]) copy(this.trits[TRUNK_TRANSACTION_HASH_OFFSET:TRUNK_TRANSACTION_HASH_END], trinary.MustTrytesToTrits(trunkTransactionHash)[:TRUNK_TRANSACTION_HASH_SIZE])
this.hasherMutex.RUnlock() this.hasherMutex.RUnlock()
this.SetModified(true) this.SetModified(true)
...@@ -217,14 +222,14 @@ func (this *MetaTransaction) SetTrunkTransactionHash(trunkTransactionHash ternar ...@@ -217,14 +222,14 @@ func (this *MetaTransaction) SetTrunkTransactionHash(trunkTransactionHash ternar
} }
// getter for the bundleHash (supports concurrency) // getter for the bundleHash (supports concurrency)
func (this *MetaTransaction) GetBranchTransactionHash() (result ternary.Trytes) { func (this *MetaTransaction) GetBranchTransactionHash() (result trinary.Trytes) {
this.branchTransactionHashMutex.RLock() this.branchTransactionHashMutex.RLock()
if this.branchTransactionHash == nil { if this.branchTransactionHash == nil {
this.branchTransactionHashMutex.RUnlock() this.branchTransactionHashMutex.RUnlock()
this.branchTransactionHashMutex.Lock() this.branchTransactionHashMutex.Lock()
defer this.branchTransactionHashMutex.Unlock() defer this.branchTransactionHashMutex.Unlock()
if this.branchTransactionHash == nil { if this.branchTransactionHash == nil {
branchTransactionHash := this.trits[BRANCH_TRANSACTION_HASH_OFFSET:BRANCH_TRANSACTION_HASH_END].ToTrytes() branchTransactionHash := trinary.MustTritsToTrytes(this.trits[BRANCH_TRANSACTION_HASH_OFFSET:BRANCH_TRANSACTION_HASH_END])
this.branchTransactionHash = &branchTransactionHash this.branchTransactionHash = &branchTransactionHash
} }
...@@ -238,7 +243,7 @@ func (this *MetaTransaction) GetBranchTransactionHash() (result ternary.Trytes) ...@@ -238,7 +243,7 @@ func (this *MetaTransaction) GetBranchTransactionHash() (result ternary.Trytes)
} }
// setter for the trunkTransactionHash (supports concurrency) // setter for the trunkTransactionHash (supports concurrency)
func (this *MetaTransaction) SetBranchTransactionHash(branchTransactionHash ternary.Trytes) bool { func (this *MetaTransaction) SetBranchTransactionHash(branchTransactionHash trinary.Trytes) bool {
this.branchTransactionHashMutex.RLock() this.branchTransactionHashMutex.RLock()
if this.branchTransactionHash == nil || *this.branchTransactionHash != branchTransactionHash { if this.branchTransactionHash == nil || *this.branchTransactionHash != branchTransactionHash {
this.branchTransactionHashMutex.RUnlock() this.branchTransactionHashMutex.RUnlock()
...@@ -248,7 +253,7 @@ func (this *MetaTransaction) SetBranchTransactionHash(branchTransactionHash tern ...@@ -248,7 +253,7 @@ func (this *MetaTransaction) SetBranchTransactionHash(branchTransactionHash tern
this.branchTransactionHash = &branchTransactionHash this.branchTransactionHash = &branchTransactionHash
this.hasherMutex.RLock() this.hasherMutex.RLock()
copy(this.trits[BRANCH_TRANSACTION_HASH_OFFSET:BRANCH_TRANSACTION_HASH_END], branchTransactionHash.ToTrits()[:BRANCH_TRANSACTION_HASH_SIZE]) copy(this.trits[BRANCH_TRANSACTION_HASH_OFFSET:BRANCH_TRANSACTION_HASH_END], trinary.MustTrytesToTrits(branchTransactionHash)[:BRANCH_TRANSACTION_HASH_SIZE])
this.hasherMutex.RUnlock() this.hasherMutex.RUnlock()
this.SetModified(true) this.SetModified(true)
...@@ -366,14 +371,14 @@ func (this *MetaTransaction) SetTail(tail bool) bool { ...@@ -366,14 +371,14 @@ func (this *MetaTransaction) SetTail(tail bool) bool {
} }
// getter for the transaction type (supports concurrency) // getter for the transaction type (supports concurrency)
func (this *MetaTransaction) GetTransactionType() (result ternary.Trytes) { func (this *MetaTransaction) GetTransactionType() (result trinary.Trytes) {
this.transactionTypeMutex.RLock() this.transactionTypeMutex.RLock()
if this.transactionType == nil { if this.transactionType == nil {
this.transactionTypeMutex.RUnlock() this.transactionTypeMutex.RUnlock()
this.transactionTypeMutex.Lock() this.transactionTypeMutex.Lock()
defer this.transactionTypeMutex.Unlock() defer this.transactionTypeMutex.Unlock()
if this.transactionType == nil { if this.transactionType == nil {
transactionType := this.trits[TRANSACTION_TYPE_OFFSET:TRANSACTION_TYPE_END].ToTrytes() transactionType := trinary.MustTritsToTrytes(this.trits[TRANSACTION_TYPE_OFFSET:TRANSACTION_TYPE_END])
this.transactionType = &transactionType this.transactionType = &transactionType
} }
...@@ -387,7 +392,7 @@ func (this *MetaTransaction) GetTransactionType() (result ternary.Trytes) { ...@@ -387,7 +392,7 @@ func (this *MetaTransaction) GetTransactionType() (result ternary.Trytes) {
} }
// setter for the transaction type (supports concurrency) // setter for the transaction type (supports concurrency)
func (this *MetaTransaction) SetTransactionType(transactionType ternary.Trytes) bool { func (this *MetaTransaction) SetTransactionType(transactionType trinary.Trytes) bool {
this.transactionTypeMutex.RLock() this.transactionTypeMutex.RLock()
if this.transactionType == nil || *this.transactionType != transactionType { if this.transactionType == nil || *this.transactionType != transactionType {
this.transactionTypeMutex.RUnlock() this.transactionTypeMutex.RUnlock()
...@@ -397,7 +402,7 @@ func (this *MetaTransaction) SetTransactionType(transactionType ternary.Trytes) ...@@ -397,7 +402,7 @@ func (this *MetaTransaction) SetTransactionType(transactionType ternary.Trytes)
this.transactionType = &transactionType this.transactionType = &transactionType
this.hasherMutex.RLock() this.hasherMutex.RLock()
copy(this.trits[TRANSACTION_TYPE_OFFSET:TRANSACTION_TYPE_END], transactionType.ToTrits()[:TRANSACTION_TYPE_SIZE]) copy(this.trits[TRANSACTION_TYPE_OFFSET:TRANSACTION_TYPE_END], trinary.MustTrytesToTrits(transactionType)[:TRANSACTION_TYPE_SIZE])
this.hasherMutex.RUnlock() this.hasherMutex.RUnlock()
this.SetModified(true) this.SetModified(true)
...@@ -413,7 +418,7 @@ func (this *MetaTransaction) SetTransactionType(transactionType ternary.Trytes) ...@@ -413,7 +418,7 @@ func (this *MetaTransaction) SetTransactionType(transactionType ternary.Trytes)
} }
// getter for the data slice (supports concurrency) // getter for the data slice (supports concurrency)
func (this *MetaTransaction) GetData() (result ternary.Trits) { func (this *MetaTransaction) GetData() (result trinary.Trits) {
this.dataMutex.RLock() this.dataMutex.RLock()
if this.data == nil { if this.data == nil {
this.dataMutex.RUnlock() this.dataMutex.RUnlock()
...@@ -431,8 +436,8 @@ func (this *MetaTransaction) GetData() (result ternary.Trits) { ...@@ -431,8 +436,8 @@ func (this *MetaTransaction) GetData() (result ternary.Trits) {
return return
} }
func (this *MetaTransaction) GetTrits() (result ternary.Trits) { func (this *MetaTransaction) GetTrits() (result trinary.Trits) {
result = make(ternary.Trits, len(this.trits)) result = make(trinary.Trits, len(this.trits))
this.hasherMutex.Lock() this.hasherMutex.Lock()
copy(result, this.trits) copy(result, this.trits)
...@@ -449,7 +454,7 @@ func (this *MetaTransaction) GetBytes() (result []byte) { ...@@ -449,7 +454,7 @@ func (this *MetaTransaction) GetBytes() (result []byte) {
defer this.bytesMutex.Unlock() defer this.bytesMutex.Unlock()
this.hasherMutex.Lock() this.hasherMutex.Lock()
this.bytes = this.trits.ToBytes() this.bytes = trinary.TritsToBytes(this.trits)
this.hasherMutex.Unlock() this.hasherMutex.Unlock()
} else { } else {
this.bytesMutex.RUnlock() this.bytesMutex.RUnlock()
......
...@@ -5,17 +5,17 @@ import ( ...@@ -5,17 +5,17 @@ import (
"sync" "sync"
"testing" "testing"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
"github.com/magiconair/properties/assert" "github.com/magiconair/properties/assert"
) )
func TestMetaTransaction_SettersGetters(t *testing.T) { func TestMetaTransaction_SettersGetters(t *testing.T) {
shardMarker := ternary.Trytes("NPHTQORL9XKA") shardMarker := trinary.Trytes("NPHTQORL9XKA")
trunkTransactionHash := ternary.Trytes("99999999999999999999999999999999999999999999999999999999999999999999999999999999A") trunkTransactionHash := trinary.Trytes("99999999999999999999999999999999999999999999999999999999999999999999999999999999A")
branchTransactionHash := ternary.Trytes("99999999999999999999999999999999999999999999999999999999999999999999999999999999B") branchTransactionHash := trinary.Trytes("99999999999999999999999999999999999999999999999999999999999999999999999999999999B")
head := true head := true
tail := true tail := true
transactionType := ternary.Trytes("9999999999999999999999") transactionType := trinary.Trytes("9999999999999999999999")
transaction := New() transaction := New()
transaction.SetShardMarker(shardMarker) transaction.SetShardMarker(shardMarker)
......
...@@ -6,16 +6,17 @@ import ( ...@@ -6,16 +6,17 @@ import (
"github.com/iotaledger/goshimmer/packages/bitutils" "github.com/iotaledger/goshimmer/packages/bitutils"
"github.com/iotaledger/goshimmer/packages/errors" "github.com/iotaledger/goshimmer/packages/errors"
"github.com/iotaledger/goshimmer/packages/ternary"
"github.com/iotaledger/goshimmer/packages/typeutils" "github.com/iotaledger/goshimmer/packages/typeutils"
"github.com/iotaledger/goshimmer/packages/unsafeconvert"
"github.com/iotaledger/iota.go/trinary"
) )
// region type definition and constructor ////////////////////////////////////////////////////////////////////////////// // region type definition and constructor //////////////////////////////////////////////////////////////////////////////
type TransactionMetadata struct { type TransactionMetadata struct {
hash ternary.Trytes hash trinary.Trytes
hashMutex sync.RWMutex hashMutex sync.RWMutex
bundleHeadHash ternary.Trytes bundleHeadHash trinary.Trytes
bundleHeadHashMutex sync.RWMutex bundleHeadHashMutex sync.RWMutex
receivedTime time.Time receivedTime time.Time
receivedTimeMutex sync.RWMutex receivedTimeMutex sync.RWMutex
...@@ -29,7 +30,7 @@ type TransactionMetadata struct { ...@@ -29,7 +30,7 @@ type TransactionMetadata struct {
modifiedMutex sync.RWMutex modifiedMutex sync.RWMutex
} }
func New(hash ternary.Trytes) *TransactionMetadata { func New(hash trinary.Trytes) *TransactionMetadata {
return &TransactionMetadata{ return &TransactionMetadata{
hash: hash, hash: hash,
receivedTime: time.Now(), receivedTime: time.Now(),
...@@ -44,14 +45,14 @@ func New(hash ternary.Trytes) *TransactionMetadata { ...@@ -44,14 +45,14 @@ func New(hash ternary.Trytes) *TransactionMetadata {
// region getters and setters ////////////////////////////////////////////////////////////////////////////////////////// // region getters and setters //////////////////////////////////////////////////////////////////////////////////////////
func (metadata *TransactionMetadata) GetHash() ternary.Trytes { func (metadata *TransactionMetadata) GetHash() trinary.Trytes {
metadata.hashMutex.RLock() metadata.hashMutex.RLock()
defer metadata.hashMutex.RUnlock() defer metadata.hashMutex.RUnlock()
return metadata.hash return metadata.hash
} }
func (metadata *TransactionMetadata) SetHash(hash ternary.Trytes) { func (metadata *TransactionMetadata) SetHash(hash trinary.Trytes) {
metadata.hashMutex.RLock() metadata.hashMutex.RLock()
if metadata.hash != hash { if metadata.hash != hash {
metadata.hashMutex.RUnlock() metadata.hashMutex.RUnlock()
...@@ -67,14 +68,14 @@ func (metadata *TransactionMetadata) SetHash(hash ternary.Trytes) { ...@@ -67,14 +68,14 @@ func (metadata *TransactionMetadata) SetHash(hash ternary.Trytes) {
} }
} }
func (metadata *TransactionMetadata) GetBundleHeadHash() ternary.Trytes { func (metadata *TransactionMetadata) GetBundleHeadHash() trinary.Trytes {
metadata.bundleHeadHashMutex.RLock() metadata.bundleHeadHashMutex.RLock()
defer metadata.bundleHeadHashMutex.RUnlock() defer metadata.bundleHeadHashMutex.RUnlock()
return metadata.bundleHeadHash return metadata.bundleHeadHash
} }
func (metadata *TransactionMetadata) SetBundleHeadHash(bundleTailHash ternary.Trytes) { func (metadata *TransactionMetadata) SetBundleHeadHash(bundleTailHash trinary.Trytes) {
metadata.bundleHeadHashMutex.RLock() metadata.bundleHeadHashMutex.RLock()
if metadata.bundleHeadHash != bundleTailHash { if metadata.bundleHeadHash != bundleTailHash {
metadata.bundleHeadHashMutex.RUnlock() metadata.bundleHeadHashMutex.RUnlock()
...@@ -218,7 +219,7 @@ func (metadata *TransactionMetadata) Marshal() ([]byte, errors.IdentifiableError ...@@ -218,7 +219,7 @@ func (metadata *TransactionMetadata) Marshal() ([]byte, errors.IdentifiableError
metadata.finalizedMutex.RLock() metadata.finalizedMutex.RLock()
defer metadata.finalizedMutex.RUnlock() defer metadata.finalizedMutex.RUnlock()
copy(marshaledMetadata[MARSHALED_HASH_START:MARSHALED_HASH_END], metadata.hash.CastToBytes()) copy(marshaledMetadata[MARSHALED_HASH_START:MARSHALED_HASH_END], unsafeconvert.StringToBytes(metadata.hash))
marshaledReceivedTime, err := metadata.receivedTime.MarshalBinary() marshaledReceivedTime, err := metadata.receivedTime.MarshalBinary()
if err != nil { if err != nil {
...@@ -253,7 +254,7 @@ func (metadata *TransactionMetadata) Unmarshal(data []byte) errors.IdentifiableE ...@@ -253,7 +254,7 @@ func (metadata *TransactionMetadata) Unmarshal(data []byte) errors.IdentifiableE
metadata.finalizedMutex.Lock() metadata.finalizedMutex.Lock()
defer metadata.finalizedMutex.Unlock() defer metadata.finalizedMutex.Unlock()
metadata.hash = ternary.Trytes(typeutils.BytesToString(data[MARSHALED_HASH_START:MARSHALED_HASH_END])) metadata.hash = trinary.Trytes(typeutils.BytesToString(data[MARSHALED_HASH_START:MARSHALED_HASH_END]))
if err := metadata.receivedTime.UnmarshalBinary(data[MARSHALED_RECEIVED_TIME_START:MARSHALED_RECEIVED_TIME_END]); err != nil { if err := metadata.receivedTime.UnmarshalBinary(data[MARSHALED_RECEIVED_TIME_START:MARSHALED_RECEIVED_TIME_END]); err != nil {
return ErrUnmarshalFailed.Derive(err, "could not unmarshal the received time") return ErrUnmarshalFailed.Derive(err, "could not unmarshal the received time")
......
...@@ -3,7 +3,7 @@ package value_transaction ...@@ -3,7 +3,7 @@ package value_transaction
import ( import (
"strings" "strings"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
) )
const ( const (
...@@ -30,5 +30,5 @@ const ( ...@@ -30,5 +30,5 @@ const (
) )
var ( var (
EMPTY_SIGNATURE = ternary.Trytes(strings.Repeat("9", SIGNATURE_MESSAGE_FRAGMENT_SIZE/ternary.NUMBER_OF_TRITS_IN_A_TRYTE)) EMPTY_SIGNATURE = trinary.Trytes(strings.Repeat("9", SIGNATURE_MESSAGE_FRAGMENT_SIZE/3))
) )
...@@ -4,24 +4,24 @@ import ( ...@@ -4,24 +4,24 @@ import (
"sync" "sync"
"github.com/iotaledger/goshimmer/packages/model/meta_transaction" "github.com/iotaledger/goshimmer/packages/model/meta_transaction"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
) )
type ValueTransaction struct { type ValueTransaction struct {
*meta_transaction.MetaTransaction *meta_transaction.MetaTransaction
address *ternary.Trytes address *trinary.Trytes
addressMutex sync.RWMutex addressMutex sync.RWMutex
value *int64 value *int64
valueMutex sync.RWMutex valueMutex sync.RWMutex
timestamp *uint timestamp *uint
timestampMutex sync.RWMutex timestampMutex sync.RWMutex
nonce *ternary.Trytes nonce *trinary.Trytes
nonceMutex sync.RWMutex nonceMutex sync.RWMutex
signatureMessageFragment *ternary.Trytes signatureMessageFragment *trinary.Trytes
signatureMessageFragmentMutex sync.RWMutex signatureMessageFragmentMutex sync.RWMutex
trits ternary.Trits trits trinary.Trits
} }
func New() (result *ValueTransaction) { func New() (result *ValueTransaction) {
...@@ -42,8 +42,13 @@ func FromMetaTransaction(metaTransaction *meta_transaction.MetaTransaction) *Val ...@@ -42,8 +42,13 @@ func FromMetaTransaction(metaTransaction *meta_transaction.MetaTransaction) *Val
} }
func FromBytes(bytes []byte) (result *ValueTransaction) { func FromBytes(bytes []byte) (result *ValueTransaction) {
trits, err := trinary.BytesToTrits(bytes)
if err != nil {
panic(err)
}
result = &ValueTransaction{ result = &ValueTransaction{
MetaTransaction: meta_transaction.FromTrits(ternary.BytesToTrits(bytes)[:meta_transaction.MARSHALED_TOTAL_SIZE]), MetaTransaction: meta_transaction.FromTrits(trits[:meta_transaction.MARSHALED_TOTAL_SIZE]),
} }
result.trits = result.MetaTransaction.GetData() result.trits = result.MetaTransaction.GetData()
...@@ -52,14 +57,14 @@ func FromBytes(bytes []byte) (result *ValueTransaction) { ...@@ -52,14 +57,14 @@ func FromBytes(bytes []byte) (result *ValueTransaction) {
} }
// getter for the address (supports concurrency) // getter for the address (supports concurrency)
func (this *ValueTransaction) GetAddress() (result ternary.Trytes) { func (this *ValueTransaction) GetAddress() (result trinary.Trytes) {
this.addressMutex.RLock() this.addressMutex.RLock()
if this.address == nil { if this.address == nil {
this.addressMutex.RUnlock() this.addressMutex.RUnlock()
this.addressMutex.Lock() this.addressMutex.Lock()
defer this.addressMutex.Unlock() defer this.addressMutex.Unlock()
if this.address == nil { if this.address == nil {
address := this.trits[ADDRESS_OFFSET:ADDRESS_END].ToTrytes() address := trinary.MustTritsToTrytes(this.trits[ADDRESS_OFFSET:ADDRESS_END])
this.address = &address this.address = &address
} }
...@@ -73,7 +78,7 @@ func (this *ValueTransaction) GetAddress() (result ternary.Trytes) { ...@@ -73,7 +78,7 @@ func (this *ValueTransaction) GetAddress() (result ternary.Trytes) {
} }
// setter for the address (supports concurrency) // setter for the address (supports concurrency)
func (this *ValueTransaction) SetAddress(address ternary.Trytes) bool { func (this *ValueTransaction) SetAddress(address trinary.Trytes) bool {
this.addressMutex.RLock() this.addressMutex.RLock()
if this.address == nil || *this.address != address { if this.address == nil || *this.address != address {
this.addressMutex.RUnlock() this.addressMutex.RUnlock()
...@@ -83,7 +88,7 @@ func (this *ValueTransaction) SetAddress(address ternary.Trytes) bool { ...@@ -83,7 +88,7 @@ func (this *ValueTransaction) SetAddress(address ternary.Trytes) bool {
this.address = &address this.address = &address
this.BlockHasher() this.BlockHasher()
copy(this.trits[ADDRESS_OFFSET:ADDRESS_END], address.ToTrits()[:ADDRESS_SIZE]) copy(this.trits[ADDRESS_OFFSET:ADDRESS_END], trinary.MustTrytesToTrits(address)[:ADDRESS_SIZE])
this.UnblockHasher() this.UnblockHasher()
this.SetModified(true) this.SetModified(true)
...@@ -106,7 +111,7 @@ func (this *ValueTransaction) GetValue() (result int64) { ...@@ -106,7 +111,7 @@ func (this *ValueTransaction) GetValue() (result int64) {
this.valueMutex.Lock() this.valueMutex.Lock()
defer this.valueMutex.Unlock() defer this.valueMutex.Unlock()
if this.value == nil { if this.value == nil {
value := this.trits[VALUE_OFFSET:VALUE_END].ToInt64() value := trinary.TritsToInt(this.trits[VALUE_OFFSET:VALUE_END])
this.value = &value this.value = &value
} }
...@@ -130,7 +135,7 @@ func (this *ValueTransaction) SetValue(value int64) bool { ...@@ -130,7 +135,7 @@ func (this *ValueTransaction) SetValue(value int64) bool {
this.value = &value this.value = &value
this.BlockHasher() this.BlockHasher()
copy(this.trits[VALUE_OFFSET:VALUE_END], ternary.Int64ToTrits(value)[:VALUE_SIZE]) copy(this.trits[VALUE_OFFSET:], trinary.IntToTrits(value))
this.UnblockHasher() this.UnblockHasher()
this.SetModified(true) this.SetModified(true)
...@@ -153,7 +158,7 @@ func (this *ValueTransaction) GetTimestamp() (result uint) { ...@@ -153,7 +158,7 @@ func (this *ValueTransaction) GetTimestamp() (result uint) {
this.timestampMutex.Lock() this.timestampMutex.Lock()
defer this.timestampMutex.Unlock() defer this.timestampMutex.Unlock()
if this.timestamp == nil { if this.timestamp == nil {
timestamp := this.trits[TIMESTAMP_OFFSET:TIMESTAMP_END].ToUint() timestamp := uint(trinary.TritsToInt(this.trits[TIMESTAMP_OFFSET:TIMESTAMP_END]))
this.timestamp = &timestamp this.timestamp = &timestamp
} }
...@@ -177,7 +182,7 @@ func (this *ValueTransaction) SetTimestamp(timestamp uint) bool { ...@@ -177,7 +182,7 @@ func (this *ValueTransaction) SetTimestamp(timestamp uint) bool {
this.timestamp = &timestamp this.timestamp = &timestamp
this.BlockHasher() this.BlockHasher()
copy(this.trits[TIMESTAMP_OFFSET:TIMESTAMP_END], ternary.UintToTrits(timestamp)[:TIMESTAMP_SIZE]) copy(this.trits[TIMESTAMP_OFFSET:TIMESTAMP_END], trinary.IntToTrits(int64(timestamp))[:TIMESTAMP_SIZE])
this.UnblockHasher() this.UnblockHasher()
this.SetModified(true) this.SetModified(true)
...@@ -192,12 +197,12 @@ func (this *ValueTransaction) SetTimestamp(timestamp uint) bool { ...@@ -192,12 +197,12 @@ func (this *ValueTransaction) SetTimestamp(timestamp uint) bool {
return false return false
} }
func (this *ValueTransaction) GetBundleEssence() (result ternary.Trits) { func (this *ValueTransaction) GetBundleEssence() (result trinary.Trits) {
this.addressMutex.RLock() this.addressMutex.RLock()
this.valueMutex.RLock() this.valueMutex.RLock()
this.signatureMessageFragmentMutex.RLock() this.signatureMessageFragmentMutex.RLock()
result = make(ternary.Trits, BUNDLE_ESSENCE_SIZE) result = make(trinary.Trits, BUNDLE_ESSENCE_SIZE)
copy(result[0:], this.trits[ADDRESS_OFFSET:VALUE_END]) copy(result[0:], this.trits[ADDRESS_OFFSET:VALUE_END])
...@@ -213,14 +218,14 @@ func (this *ValueTransaction) GetBundleEssence() (result ternary.Trits) { ...@@ -213,14 +218,14 @@ func (this *ValueTransaction) GetBundleEssence() (result ternary.Trits) {
} }
// getter for the nonce (supports concurrency) // getter for the nonce (supports concurrency)
func (this *ValueTransaction) GetNonce() (result ternary.Trytes) { func (this *ValueTransaction) GetNonce() (result trinary.Trytes) {
this.nonceMutex.RLock() this.nonceMutex.RLock()
if this.nonce == nil { if this.nonce == nil {
this.nonceMutex.RUnlock() this.nonceMutex.RUnlock()
this.nonceMutex.Lock() this.nonceMutex.Lock()
defer this.nonceMutex.Unlock() defer this.nonceMutex.Unlock()
if this.nonce == nil { if this.nonce == nil {
nonce := this.trits[NONCE_OFFSET:NONCE_END].ToTrytes() nonce := trinary.MustTritsToTrytes(this.trits[NONCE_OFFSET:NONCE_END])
this.nonce = &nonce this.nonce = &nonce
} }
...@@ -234,7 +239,7 @@ func (this *ValueTransaction) GetNonce() (result ternary.Trytes) { ...@@ -234,7 +239,7 @@ func (this *ValueTransaction) GetNonce() (result ternary.Trytes) {
} }
// setter for the nonce (supports concurrency) // setter for the nonce (supports concurrency)
func (this *ValueTransaction) SetNonce(nonce ternary.Trytes) bool { func (this *ValueTransaction) SetNonce(nonce trinary.Trytes) bool {
this.nonceMutex.RLock() this.nonceMutex.RLock()
if this.nonce == nil || *this.nonce != nonce { if this.nonce == nil || *this.nonce != nonce {
this.nonceMutex.RUnlock() this.nonceMutex.RUnlock()
...@@ -244,7 +249,7 @@ func (this *ValueTransaction) SetNonce(nonce ternary.Trytes) bool { ...@@ -244,7 +249,7 @@ func (this *ValueTransaction) SetNonce(nonce ternary.Trytes) bool {
this.nonce = &nonce this.nonce = &nonce
this.BlockHasher() this.BlockHasher()
copy(this.trits[NONCE_OFFSET:NONCE_END], nonce.ToTrits()[:NONCE_SIZE]) copy(this.trits[NONCE_OFFSET:NONCE_END], trinary.MustTrytesToTrits(nonce)[:NONCE_SIZE])
this.UnblockHasher() this.UnblockHasher()
this.SetModified(true) this.SetModified(true)
...@@ -260,14 +265,14 @@ func (this *ValueTransaction) SetNonce(nonce ternary.Trytes) bool { ...@@ -260,14 +265,14 @@ func (this *ValueTransaction) SetNonce(nonce ternary.Trytes) bool {
} }
// getter for the signatureMessageFragmetn (supports concurrency) // getter for the signatureMessageFragmetn (supports concurrency)
func (this *ValueTransaction) GetSignatureMessageFragment() (result ternary.Trytes) { func (this *ValueTransaction) GetSignatureMessageFragment() (result trinary.Trytes) {
this.signatureMessageFragmentMutex.RLock() this.signatureMessageFragmentMutex.RLock()
if this.signatureMessageFragment == nil { if this.signatureMessageFragment == nil {
this.signatureMessageFragmentMutex.RUnlock() this.signatureMessageFragmentMutex.RUnlock()
this.signatureMessageFragmentMutex.Lock() this.signatureMessageFragmentMutex.Lock()
defer this.signatureMessageFragmentMutex.Unlock() defer this.signatureMessageFragmentMutex.Unlock()
if this.signatureMessageFragment == nil { if this.signatureMessageFragment == nil {
signatureMessageFragment := this.trits[SIGNATURE_MESSAGE_FRAGMENT_OFFSET:SIGNATURE_MESSAGE_FRAGMENT_END].ToTrytes() signatureMessageFragment := trinary.MustTritsToTrytes(this.trits[SIGNATURE_MESSAGE_FRAGMENT_OFFSET:SIGNATURE_MESSAGE_FRAGMENT_END])
this.signatureMessageFragment = &signatureMessageFragment this.signatureMessageFragment = &signatureMessageFragment
} }
...@@ -281,7 +286,7 @@ func (this *ValueTransaction) GetSignatureMessageFragment() (result ternary.Tryt ...@@ -281,7 +286,7 @@ func (this *ValueTransaction) GetSignatureMessageFragment() (result ternary.Tryt
} }
// setter for the nonce (supports concurrency) // setter for the nonce (supports concurrency)
func (this *ValueTransaction) SetSignatureMessageFragment(signatureMessageFragment ternary.Trytes) bool { func (this *ValueTransaction) SetSignatureMessageFragment(signatureMessageFragment trinary.Trytes) bool {
this.signatureMessageFragmentMutex.RLock() this.signatureMessageFragmentMutex.RLock()
if this.signatureMessageFragment == nil || *this.signatureMessageFragment != signatureMessageFragment { if this.signatureMessageFragment == nil || *this.signatureMessageFragment != signatureMessageFragment {
this.signatureMessageFragmentMutex.RUnlock() this.signatureMessageFragmentMutex.RUnlock()
...@@ -291,7 +296,7 @@ func (this *ValueTransaction) SetSignatureMessageFragment(signatureMessageFragme ...@@ -291,7 +296,7 @@ func (this *ValueTransaction) SetSignatureMessageFragment(signatureMessageFragme
this.signatureMessageFragment = &signatureMessageFragment this.signatureMessageFragment = &signatureMessageFragment
this.BlockHasher() this.BlockHasher()
copy(this.trits[SIGNATURE_MESSAGE_FRAGMENT_OFFSET:SIGNATURE_MESSAGE_FRAGMENT_END], signatureMessageFragment.ToTrits()[:SIGNATURE_MESSAGE_FRAGMENT_SIZE]) copy(this.trits[SIGNATURE_MESSAGE_FRAGMENT_OFFSET:SIGNATURE_MESSAGE_FRAGMENT_END], trinary.MustTrytesToTrits(signatureMessageFragment)[:SIGNATURE_MESSAGE_FRAGMENT_SIZE])
this.UnblockHasher() this.UnblockHasher()
this.SetModified(true) this.SetModified(true)
......
...@@ -4,12 +4,12 @@ import ( ...@@ -4,12 +4,12 @@ import (
"fmt" "fmt"
"testing" "testing"
"github.com/iotaledger/goshimmer/packages/ternary" "github.com/iotaledger/iota.go/trinary"
"github.com/magiconair/properties/assert" "github.com/magiconair/properties/assert"
) )
func TestValueTransaction_SettersGetters(t *testing.T) { func TestValueTransaction_SettersGetters(t *testing.T) {
address := ternary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F") address := trinary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
transaction := New() transaction := New()
transaction.SetAddress(address) transaction.SetAddress(address)
......
package ternary package ternary
import (
. "github.com/iotaledger/iota.go/trinary"
)
type BCTernaryDemultiplexer struct { type BCTernaryDemultiplexer struct {
bcTrits BCTrits bcTrits BCTrits
} }
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment