Use iota.go

go.mod

@@ -3,7 +3,6 @@ module github.com/iotaledger/goshimmer
 go 1.12
 
 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/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
@@ -12,6 +11,7 @@ require (
 	github.com/go-zeromq/zmq4 v0.4.0
 	github.com/golang/protobuf v1.3.1 // indirect
 	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/gommon v0.2.9 // indirect
 	github.com/magiconair/properties v1.8.1

go.sum

@@ -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/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/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/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/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/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/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
 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/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/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/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
 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/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/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/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/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/go.mod h1:0INS7j/VjnFxD4E2wkz67b8cVwCLbBmJyDaka6Cmk1s=
 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
 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/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.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 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
 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/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.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
 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
 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/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/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-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/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-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-20190611141213-3f473d35a33a h1:+KkCgOMgnKSgenxTBoiwkMqTiouMIy/3o8RLdmSbGoY=
 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/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-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/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/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 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=

packages/curl/batch_hasher.go

@@ -6,11 +6,12 @@ import (
 	"time"
 
 	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/iota.go/trinary"
 )
 
 type HashRequest struct {
-	input  ternary.Trits
-	output chan ternary.Trits
+	input  trinary.Trits
+	output chan trinary.Trits
 }
 
 type BatchHasher struct {
@@ -94,7 +95,7 @@ func (this *BatchHasher) processHashes(collectedHashRequests []HashRequest) {
 			close(hashRequest.output)
 		}
 	} else {
-		var resp = make(ternary.Trits, this.hashLength)
+		var resp = make(trinary.Trits, this.hashLength)
 
 		curl := NewCurl(this.hashLength, this.rounds)
 		curl.Absorb(collectedHashRequests[0].input, 0, len(collectedHashRequests[0].input))
@@ -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{
 		input:  trits,
-		output: make(chan ternary.Trits, 1),
+		output: make(chan trinary.Trits, 1),
 	}
 
 	this.hashRequests <- hashRequest

packages/curl/bct_curl.go

@@ -3,7 +3,8 @@ package curl
 import "github.com/iotaledger/goshimmer/packages/ternary"
 
 const (
-	HIGH_LONG_BITS = 0xFFFFFFFFFFFFFFFF
+	HIGH_LONG_BITS             = 0xFFFFFFFFFFFFFFFF
+	NUMBER_OF_TRITS_IN_A_TRYTE = 3
 )
 
 type BCTCurl struct {
@@ -18,10 +19,10 @@ func NewBCTCurl(hashLength int, numberOfRounds int) *BCTCurl {
 	this := &BCTCurl{
 		hashLength:     hashLength,
 		numberOfRounds: numberOfRounds,
-		stateLength:    ternary.NUMBER_OF_TRITS_IN_A_TRYTE * hashLength,
+		stateLength:    NUMBER_OF_TRITS_IN_A_TRYTE * hashLength,
 		state: ternary.BCTrits{
-			Lo: make([]uint, ternary.NUMBER_OF_TRITS_IN_A_TRYTE*hashLength),
-			Hi: make([]uint, ternary.NUMBER_OF_TRITS_IN_A_TRYTE*hashLength),
+			Lo: make([]uint, NUMBER_OF_TRITS_IN_A_TRYTE*hashLength),
+			Hi: make([]uint, NUMBER_OF_TRITS_IN_A_TRYTE*hashLength),
 		},
 		cTransform: nil,
 	}

packages/curl/curl.go

@@ -3,16 +3,16 @@ package curl
 import (
 	"math"
 
-	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/iota.go/trinary"
 )
 
 const (
 	HASH_LENGTH  = 243
-	STATE_LENGTH = ternary.NUMBER_OF_TRITS_IN_A_TRYTE * HASH_LENGTH
+	STATE_LENGTH = 3 * HASH_LENGTH
 )
 
 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 {
@@ -25,7 +25,7 @@ type Hash interface {
 
 type Curl struct {
 	Hash
-	state      ternary.Trits
+	state      trinary.Trits
 	hashLength int
 	rounds     int
 }
@@ -45,12 +45,12 @@ func (curl *Curl) Initialize() {
 	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
 	if trits != nil {
 		curl.state = trits
 	} else {
-		curl.state = make(ternary.Trits, STATE_LENGTH)
+		curl.state = make(trinary.Trits, STATE_LENGTH)
 	}
 }
 
@@ -58,7 +58,7 @@ func (curl *Curl) Reset() {
 	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 {
 		limit := int(math.Min(HASH_LENGTH, float64(length)))
 		copy(curl.state, trits[offset:offset+limit])
@@ -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 {
 		limit := int(math.Min(HASH_LENGTH, float64(length)))
 		copy(resp[offset:offset+limit], curl.state)
@@ -88,7 +88,7 @@ func (curl *Curl) Squeeze(resp ternary.Trits, offset int, length int) ternary.Tr
 func (curl *Curl) Transform() {
 	var index = 0
 	for round := 0; round < curl.rounds; round++ {
-		stateCopy := make(ternary.Trits, STATE_LENGTH)
+		stateCopy := make(trinary.Trits, STATE_LENGTH)
 		copy(stateCopy, curl.state)
 		for i := 0; i < STATE_LENGTH; i++ {
 			incr := 364

packages/iac/area.go

@@ -4,12 +4,12 @@ import (
 	"math"
 
 	olc "github.com/google/open-location-code/go"
-	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/iota.go/trinary"
 )
 
 type Area struct {
 	olc.CodeArea
-	IACCode ternary.Trytes
+	IACCode trinary.Trytes
 	OLCCode string
 }
 

packages/iac/iac.go

@@ -3,10 +3,10 @@ package iac
 import (
 	olc "github.com/google/open-location-code/go"
 	"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 {
 		err = conversionErr
 	} else {

packages/iac/olc_conversion.go

@@ -2,7 +2,7 @@ package iac
 
 import (
 	"github.com/iotaledger/goshimmer/packages/errors"
-	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/iota.go/trinary"
 )
 
 var (
@@ -31,10 +31,10 @@ func init() {
 	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 {
 		if translatedChar, exists := OLC_TO_IAC_MAP[char]; exists {
-			result += ternary.Trytes(translatedChar)
+			result += trinary.Trytes(translatedChar)
 		} else {
 			err = ErrConversionFailed.Derive("invalid character in input")
 		}
@@ -43,7 +43,7 @@ func TrytesFromOLCCode(code string) (result ternary.Trytes, err errors.Identifia
 	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 {
 		if translatedChar, exists := IAC_TO_OLC_MAP[char]; exists {
 			result += string(translatedChar)

packages/model/approvers/approvers.go

@@ -6,40 +6,41 @@ import (
 	"sync"
 
 	"github.com/iotaledger/goshimmer/packages/errors"
-	"github.com/iotaledger/goshimmer/packages/ternary"
 	"github.com/iotaledger/goshimmer/packages/typeutils"
+	"github.com/iotaledger/goshimmer/packages/unsafeconvert"
+	"github.com/iotaledger/iota.go/trinary"
 )
 
 type Approvers struct {
-	hash        ternary.Trytes
-	hashes      map[ternary.Trytes]bool
+	hash        trinary.Trytes
+	hashes      map[trinary.Trytes]bool
 	hashesMutex sync.RWMutex
 	modified    bool
 }
 
-func New(hash ternary.Trytes) *Approvers {
+func New(hash trinary.Trytes) *Approvers {
 	return &Approvers{
 		hash:     hash,
-		hashes:   make(map[ternary.Trytes]bool),
+		hashes:   make(map[trinary.Trytes]bool),
 		modified: false,
 	}
 }
 
 // region public methods with locking //////////////////////////////////////////////////////////////////////////////////
 
-func (approvers *Approvers) Add(transactionHash ternary.Trytes) {
+func (approvers *Approvers) Add(transactionHash trinary.Trytes) {
 	approvers.hashesMutex.Lock()
 	approvers.add(transactionHash)
 	approvers.hashesMutex.Unlock()
 }
 
-func (approvers *Approvers) Remove(approverHash ternary.Trytes) {
+func (approvers *Approvers) Remove(approverHash trinary.Trytes) {
 	approvers.hashesMutex.Lock()
 	approvers.remove(approverHash)
 	approvers.hashesMutex.Unlock()
 }
 
-func (approvers *Approvers) GetHashes() (result []ternary.Trytes) {
+func (approvers *Approvers) GetHashes() (result []trinary.Trytes) {
 	approvers.hashesMutex.RLock()
 	result = approvers.getHashes()
 	approvers.hashesMutex.RUnlock()
@@ -47,7 +48,7 @@ func (approvers *Approvers) GetHashes() (result []ternary.Trytes) {
 	return
 }
 
-func (approvers *Approvers) GetHash() (result ternary.Trytes) {
+func (approvers *Approvers) GetHash() (result trinary.Trytes) {
 	approvers.hashesMutex.RLock()
 	result = approvers.hash
 	approvers.hashesMutex.RUnlock()
@@ -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)))
 
-	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
 	for hash := range approvers.hashes {
 		var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(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++
 	}
@@ -101,13 +102,13 @@ func (approvers *Approvers) Unmarshal(data []byte) (err errors.IdentifiableError
 
 	approvers.hashesMutex.Lock()
 
-	approvers.hash = ternary.Trytes(typeutils.BytesToString(data[MARSHALED_APPROVERS_HASH_START:MARSHALED_APPROVERS_HASH_END]))
-	approvers.hashes = make(map[ternary.Trytes]bool, hashesCount)
+	approvers.hash = trinary.Trytes(typeutils.BytesToString(data[MARSHALED_APPROVERS_HASH_START:MARSHALED_APPROVERS_HASH_END]))
+	approvers.hashes = make(map[trinary.Trytes]bool, hashesCount)
 	for i := uint64(0); i < hashesCount; i++ {
 		var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(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()
@@ -119,22 +120,22 @@ func (approvers *Approvers) Unmarshal(data []byte) (err errors.IdentifiableError
 
 // 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 {
 		approvers.hashes[transactionHash] = true
 		approvers.modified = true
 	}
 }
 
-func (approvers *Approvers) remove(approverHash ternary.Trytes) {
+func (approvers *Approvers) remove(approverHash trinary.Trytes) {
 	if _, exists := approvers.hashes[approverHash]; exists {
 		delete(approvers.hashes, approverHash)
 		approvers.modified = true
 	}
 }
 
-func (approvers *Approvers) getHashes() (result []ternary.Trytes) {
-	result = make([]ternary.Trytes, len(approvers.hashes))
+func (approvers *Approvers) getHashes() (result []trinary.Trytes) {
+	result = make([]trinary.Trytes, len(approvers.hashes))
 
 	counter := 0
 	for hash := range approvers.hashes {

packages/model/approvers/approvers_test.go

@@ -4,13 +4,13 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/iota.go/trinary"
 	"github.com/magiconair/properties/assert"
 )
 
 func TestApprovers_SettersGetters(t *testing.T) {
-	hashA := ternary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
-	hashB := ternary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
+	hashA := trinary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
+	hashB := trinary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
 	approversTest := New(hashA)
 	approversTest.Add(hashB)
 
@@ -19,8 +19,8 @@ func TestApprovers_SettersGetters(t *testing.T) {
 }
 
 func TestApprovers_MarshalUnmarshal(t *testing.T) {
-	hashA := ternary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
-	hashB := ternary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
+	hashA := trinary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
+	hashB := trinary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
 	approversTest := New(hashA)
 	approversTest.Add(hashB)
 

packages/model/bundle/bundle.go

@@ -9,24 +9,24 @@ import (
 	"github.com/iotaledger/goshimmer/packages/bitutils"
 	"github.com/iotaledger/goshimmer/packages/errors"
 	"github.com/iotaledger/goshimmer/packages/typeutils"
-
-	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/goshimmer/packages/unsafeconvert"
+	"github.com/iotaledger/iota.go/trinary"
 )
 
 type Bundle struct {
-	hash                   ternary.Trytes
+	hash                   trinary.Trytes
 	hashMutex              sync.RWMutex
-	transactionHashes      []ternary.Trytes
+	transactionHashes      []trinary.Trytes
 	transactionHashesMutex sync.RWMutex
 	isValueBundle          bool
 	isValueBundleMutex     sync.RWMutex
-	bundleEssenceHash      ternary.Trytes
+	bundleEssenceHash      trinary.Trytes
 	bundleEssenceHashMutex sync.RWMutex
 	modified               bool
 	modifiedMutex          sync.RWMutex
 }
 
-func New(headTransactionHash ternary.Trytes) (result *Bundle) {
+func New(headTransactionHash trinary.Trytes) (result *Bundle) {
 	result = &Bundle{
 		hash: headTransactionHash,
 	}
@@ -34,7 +34,7 @@ func New(headTransactionHash ternary.Trytes) (result *Bundle) {
 	return
 }
 
-func (bundle *Bundle) GetHash() (result ternary.Trytes) {
+func (bundle *Bundle) GetHash() (result trinary.Trytes) {
 	bundle.hashMutex.RLock()
 	result = bundle.hash
 	bundle.hashMutex.RUnlock()
@@ -42,13 +42,13 @@ func (bundle *Bundle) GetHash() (result ternary.Trytes) {
 	return
 }
 
-func (bundle *Bundle) SetHash(hash ternary.Trytes) {
+func (bundle *Bundle) SetHash(hash trinary.Trytes) {
 	bundle.hashMutex.Lock()
 	bundle.hash = hash
 	bundle.hashMutex.Unlock()
 }
 
-func (bundle *Bundle) GetTransactionHashes() (result []ternary.Trytes) {
+func (bundle *Bundle) GetTransactionHashes() (result []trinary.Trytes) {
 	bundle.bundleEssenceHashMutex.RLock()
 	result = bundle.transactionHashes
 	bundle.bundleEssenceHashMutex.RUnlock()
@@ -56,7 +56,7 @@ func (bundle *Bundle) GetTransactionHashes() (result []ternary.Trytes) {
 	return
 }
 
-func (bundle *Bundle) SetTransactionHashes(transactionHashes []ternary.Trytes) {
+func (bundle *Bundle) SetTransactionHashes(transactionHashes []trinary.Trytes) {
 	bundle.transactionHashesMutex.Lock()
 	bundle.transactionHashes = transactionHashes
 	bundle.transactionHashesMutex.Unlock()
@@ -76,7 +76,7 @@ func (bundle *Bundle) SetValueBundle(valueBundle bool) {
 	bundle.isValueBundleMutex.Unlock()
 }
 
-func (bundle *Bundle) GetBundleEssenceHash() (result ternary.Trytes) {
+func (bundle *Bundle) GetBundleEssenceHash() (result trinary.Trytes) {
 	bundle.bundleEssenceHashMutex.RLock()
 	result = bundle.bundleEssenceHash
 	bundle.bundleEssenceHashMutex.RUnlock()
@@ -84,7 +84,7 @@ func (bundle *Bundle) GetBundleEssenceHash() (result ternary.Trytes) {
 	return
 }
 
-func (bundle *Bundle) SetBundleEssenceHash(bundleEssenceHash ternary.Trytes) {
+func (bundle *Bundle) SetBundleEssenceHash(bundleEssenceHash trinary.Trytes) {
 	bundle.bundleEssenceHashMutex.Lock()
 	bundle.bundleEssenceHash = bundleEssenceHash
 	bundle.bundleEssenceHashMutex.Unlock()
@@ -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)))
 
-	copy(result[MARSHALED_HASH_START:MARSHALED_HASH_END], bundle.hash.CastToBytes())
-	copy(result[MARSHALED_BUNDLE_ESSENCE_HASH_START:MARSHALED_BUNDLE_ESSENCE_HASH_END], bundle.bundleEssenceHash.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], unsafeconvert.StringToBytes(bundle.bundleEssenceHash))
 
 	var flags bitutils.BitMask
 	if bundle.isValueBundle {
@@ -128,7 +128,7 @@ func (bundle *Bundle) Marshal() (result []byte) {
 		var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(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++
 	}
@@ -159,20 +159,20 @@ func (bundle *Bundle) Unmarshal(data []byte) (err errors.IdentifiableError) {
 	bundle.isValueBundleMutex.Lock()
 	bundle.transactionHashesMutex.Lock()
 
-	bundle.hash = ternary.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.hash = trinary.Trytes(typeutils.BytesToString(data[MARSHALED_HASH_START:MARSHALED_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])
 	if flags.HasFlag(0) {
 		bundle.isValueBundle = true
 	}
 
-	bundle.transactionHashes = make([]ternary.Trytes, hashesCount)
+	bundle.transactionHashes = make([]trinary.Trytes, hashesCount)
 	for i := uint64(0); i < hashesCount; i++ {
 		var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(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()

packages/model/bundle/bundle_test.go

@@ -3,16 +3,16 @@ package bundle
 import (
 	"testing"
 
-	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/iota.go/trinary"
 	"github.com/magiconair/properties/assert"
 )
 
 func TestBundle_SettersGetters(t *testing.T) {
-	bundleHash := ternary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
-	bundleEssenceHash := ternary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
-	transactions := []ternary.Trytes{
+	bundleHash := trinary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
+	bundleEssenceHash := trinary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
+	transactions := []trinary.Trytes{
 		bundleHash,
-		ternary.Trytes("C9999999999999999999999999999999999999999999999999999999999999999999999999999999F"),
+		trinary.Trytes("C9999999999999999999999999999999999999999999999999999999999999999999999999999999F"),
 	}
 
 	testBundle := New(bundleHash)
@@ -29,11 +29,11 @@ func TestBundle_SettersGetters(t *testing.T) {
 }
 
 func TestBundle_SettersGettersMarshalUnmarshal(t *testing.T) {
-	bundleHash := ternary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
-	bundleEssenceHash := ternary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
-	transactions := []ternary.Trytes{
+	bundleHash := trinary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
+	bundleEssenceHash := trinary.Trytes("B9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
+	transactions := []trinary.Trytes{
 		bundleHash,
-		ternary.Trytes("C9999999999999999999999999999999999999999999999999999999999999999999999999999999F"),
+		trinary.Trytes("C9999999999999999999999999999999999999999999999999999999999999999999999999999999F"),
 	}
 
 	testBundle := New(bundleHash)

packages/model/meta_transaction/constants.go

 package meta_transaction
 
 import (
-	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/iota.go/trinary"
 )
 
 const (
@@ -31,5 +31,5 @@ const (
 
 	MARSHALED_TOTAL_SIZE = DATA_END
 
-	BRANCH_NULL_HASH = ternary.Trytes("999999999999999999999999999999999999999999999999999999999999999999999999999999999")
+	BRANCH_NULL_HASH = trinary.Trytes("999999999999999999999999999999999999999999999999999999999999999999999999999999999")
 )

packages/model/meta_transaction/meta_transaction.go

@@ -4,20 +4,20 @@ import (
 	"sync"
 
 	"github.com/iotaledger/goshimmer/packages/curl"
-	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/iota.go/trinary"
 )
 
 type MetaTransaction struct {
-	hash            *ternary.Trytes
+	hash            *trinary.Trytes
 	weightMagnitude int
 
-	shardMarker           *ternary.Trytes
-	trunkTransactionHash  *ternary.Trytes
-	branchTransactionHash *ternary.Trytes
+	shardMarker           *trinary.Trytes
+	trunkTransactionHash  *trinary.Trytes
+	branchTransactionHash *trinary.Trytes
 	head                  *bool
 	tail                  *bool
-	transactionType       *ternary.Trytes
-	data                  ternary.Trits
+	transactionType       *trinary.Trytes
+	data                  trinary.Trits
 	modified              bool
 
 	hasherMutex                sync.RWMutex
@@ -32,22 +32,27 @@ type MetaTransaction struct {
 	bytesMutex                 sync.RWMutex
 	modifiedMutex              sync.RWMutex
 
-	trits ternary.Trits
+	trits trinary.Trits
 	bytes []byte
 }
 
 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{
 		trits: trits,
 	}
 }
 
 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
 
 	return
@@ -72,7 +77,7 @@ func (this *MetaTransaction) ReHash() {
 }
 
 // retrieves the hash of the transaction
-func (this *MetaTransaction) GetHash() (result ternary.Trytes) {
+func (this *MetaTransaction) GetHash() (result trinary.Trytes) {
 	this.hashMutex.RLock()
 	if this.hash == nil {
 		this.hashMutex.RUnlock()
@@ -116,21 +121,21 @@ func (this *MetaTransaction) GetWeightMagnitude() (result int) {
 // hashes the transaction using curl (without locking - internal usage)
 func (this *MetaTransaction) parseHashRelatedDetails() {
 	hashTrits := <-curl.CURLP81.Hash(this.trits)
-	hashTrytes := hashTrits.ToTrytes()
+	hashTrytes := trinary.MustTritsToTrytes(hashTrits)
 
 	this.hash = &hashTrytes
-	this.weightMagnitude = hashTrits.TrailingZeroes()
+	this.weightMagnitude = int(trinary.TrailingZeros(hashTrits))
 }
 
 // getter for the shard marker (supports concurrency)
-func (this *MetaTransaction) GetShardMarker() (result ternary.Trytes) {
+func (this *MetaTransaction) GetShardMarker() (result trinary.Trytes) {
 	this.shardMarkerMutex.RLock()
 	if this.shardMarker == nil {
 		this.shardMarkerMutex.RUnlock()
 		this.shardMarkerMutex.Lock()
 		defer this.shardMarkerMutex.Unlock()
 		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
 		}
@@ -144,7 +149,7 @@ func (this *MetaTransaction) GetShardMarker() (result ternary.Trytes) {
 }
 
 // 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()
 	if this.shardMarker == nil || *this.shardMarker != shardMarker {
 		this.shardMarkerMutex.RUnlock()
@@ -154,7 +159,7 @@ func (this *MetaTransaction) SetShardMarker(shardMarker ternary.Trytes) bool {
 			this.shardMarker = &shardMarker
 
 			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.SetModified(true)
@@ -170,14 +175,14 @@ func (this *MetaTransaction) SetShardMarker(shardMarker ternary.Trytes) bool {
 }
 
 // getter for the bundleHash (supports concurrency)
-func (this *MetaTransaction) GetTrunkTransactionHash() (result ternary.Trytes) {
+func (this *MetaTransaction) GetTrunkTransactionHash() (result trinary.Trytes) {
 	this.trunkTransactionHashMutex.RLock()
 	if this.trunkTransactionHash == nil {
 		this.trunkTransactionHashMutex.RUnlock()
 		this.trunkTransactionHashMutex.Lock()
 		defer this.trunkTransactionHashMutex.Unlock()
 		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
 		}
@@ -191,7 +196,7 @@ func (this *MetaTransaction) GetTrunkTransactionHash() (result ternary.Trytes) {
 }
 
 // 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()
 	if this.trunkTransactionHash == nil || *this.trunkTransactionHash != trunkTransactionHash {
 		this.trunkTransactionHashMutex.RUnlock()
@@ -201,7 +206,7 @@ func (this *MetaTransaction) SetTrunkTransactionHash(trunkTransactionHash ternar
 			this.trunkTransactionHash = &trunkTransactionHash
 
 			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.SetModified(true)
@@ -217,14 +222,14 @@ func (this *MetaTransaction) SetTrunkTransactionHash(trunkTransactionHash ternar
 }
 
 // getter for the bundleHash (supports concurrency)
-func (this *MetaTransaction) GetBranchTransactionHash() (result ternary.Trytes) {
+func (this *MetaTransaction) GetBranchTransactionHash() (result trinary.Trytes) {
 	this.branchTransactionHashMutex.RLock()
 	if this.branchTransactionHash == nil {
 		this.branchTransactionHashMutex.RUnlock()
 		this.branchTransactionHashMutex.Lock()
 		defer this.branchTransactionHashMutex.Unlock()
 		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
 		}
@@ -238,7 +243,7 @@ func (this *MetaTransaction) GetBranchTransactionHash() (result ternary.Trytes)
 }
 
 // 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()
 	if this.branchTransactionHash == nil || *this.branchTransactionHash != branchTransactionHash {
 		this.branchTransactionHashMutex.RUnlock()
@@ -248,7 +253,7 @@ func (this *MetaTransaction) SetBranchTransactionHash(branchTransactionHash tern
 			this.branchTransactionHash = &branchTransactionHash
 
 			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.SetModified(true)
@@ -366,14 +371,14 @@ func (this *MetaTransaction) SetTail(tail bool) bool {
 }
 
 // getter for the transaction type (supports concurrency)
-func (this *MetaTransaction) GetTransactionType() (result ternary.Trytes) {
+func (this *MetaTransaction) GetTransactionType() (result trinary.Trytes) {
 	this.transactionTypeMutex.RLock()
 	if this.transactionType == nil {
 		this.transactionTypeMutex.RUnlock()
 		this.transactionTypeMutex.Lock()
 		defer this.transactionTypeMutex.Unlock()
 		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
 		}
@@ -387,7 +392,7 @@ func (this *MetaTransaction) GetTransactionType() (result ternary.Trytes) {
 }
 
 // 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()
 	if this.transactionType == nil || *this.transactionType != transactionType {
 		this.transactionTypeMutex.RUnlock()
@@ -397,7 +402,7 @@ func (this *MetaTransaction) SetTransactionType(transactionType ternary.Trytes)
 			this.transactionType = &transactionType
 
 			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.SetModified(true)
@@ -413,7 +418,7 @@ func (this *MetaTransaction) SetTransactionType(transactionType ternary.Trytes)
 }
 
 // getter for the data slice (supports concurrency)
-func (this *MetaTransaction) GetData() (result ternary.Trits) {
+func (this *MetaTransaction) GetData() (result trinary.Trits) {
 	this.dataMutex.RLock()
 	if this.data == nil {
 		this.dataMutex.RUnlock()
@@ -431,8 +436,8 @@ func (this *MetaTransaction) GetData() (result ternary.Trits) {
 	return
 }
 
-func (this *MetaTransaction) GetTrits() (result ternary.Trits) {
-	result = make(ternary.Trits, len(this.trits))
+func (this *MetaTransaction) GetTrits() (result trinary.Trits) {
+	result = make(trinary.Trits, len(this.trits))
 
 	this.hasherMutex.Lock()
 	copy(result, this.trits)
@@ -449,7 +454,7 @@ func (this *MetaTransaction) GetBytes() (result []byte) {
 		defer this.bytesMutex.Unlock()
 
 		this.hasherMutex.Lock()
-		this.bytes = this.trits.ToBytes()
+		this.bytes = trinary.TritsToBytes(this.trits)
 		this.hasherMutex.Unlock()
 	} else {
 		this.bytesMutex.RUnlock()

packages/model/meta_transaction/meta_transaction_test.go

@@ -5,17 +5,17 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/iota.go/trinary"
 	"github.com/magiconair/properties/assert"
 )
 
 func TestMetaTransaction_SettersGetters(t *testing.T) {
-	shardMarker := ternary.Trytes("NPHTQORL9XKA")
-	trunkTransactionHash := ternary.Trytes("99999999999999999999999999999999999999999999999999999999999999999999999999999999A")
-	branchTransactionHash := ternary.Trytes("99999999999999999999999999999999999999999999999999999999999999999999999999999999B")
+	shardMarker := trinary.Trytes("NPHTQORL9XKA")
+	trunkTransactionHash := trinary.Trytes("99999999999999999999999999999999999999999999999999999999999999999999999999999999A")
+	branchTransactionHash := trinary.Trytes("99999999999999999999999999999999999999999999999999999999999999999999999999999999B")
 	head := true
 	tail := true
-	transactionType := ternary.Trytes("9999999999999999999999")
+	transactionType := trinary.Trytes("9999999999999999999999")
 
 	transaction := New()
 	transaction.SetShardMarker(shardMarker)

packages/model/transactionmetadata/transactionmetadata.go

@@ -6,16 +6,17 @@ import (
 
 	"github.com/iotaledger/goshimmer/packages/bitutils"
 	"github.com/iotaledger/goshimmer/packages/errors"
-	"github.com/iotaledger/goshimmer/packages/ternary"
 	"github.com/iotaledger/goshimmer/packages/typeutils"
+	"github.com/iotaledger/goshimmer/packages/unsafeconvert"
+	"github.com/iotaledger/iota.go/trinary"
 )
 
 // region type definition and constructor //////////////////////////////////////////////////////////////////////////////
 
 type TransactionMetadata struct {
-	hash                ternary.Trytes
+	hash                trinary.Trytes
 	hashMutex           sync.RWMutex
-	bundleHeadHash      ternary.Trytes
+	bundleHeadHash      trinary.Trytes
 	bundleHeadHashMutex sync.RWMutex
 	receivedTime        time.Time
 	receivedTimeMutex   sync.RWMutex
@@ -29,7 +30,7 @@ type TransactionMetadata struct {
 	modifiedMutex       sync.RWMutex
 }
 
-func New(hash ternary.Trytes) *TransactionMetadata {
+func New(hash trinary.Trytes) *TransactionMetadata {
 	return &TransactionMetadata{
 		hash:         hash,
 		receivedTime: time.Now(),
@@ -44,14 +45,14 @@ func New(hash ternary.Trytes) *TransactionMetadata {
 
 // region getters and setters //////////////////////////////////////////////////////////////////////////////////////////
 
-func (metadata *TransactionMetadata) GetHash() ternary.Trytes {
+func (metadata *TransactionMetadata) GetHash() trinary.Trytes {
 	metadata.hashMutex.RLock()
 	defer metadata.hashMutex.RUnlock()
 
 	return metadata.hash
 }
 
-func (metadata *TransactionMetadata) SetHash(hash ternary.Trytes) {
+func (metadata *TransactionMetadata) SetHash(hash trinary.Trytes) {
 	metadata.hashMutex.RLock()
 	if metadata.hash != hash {
 		metadata.hashMutex.RUnlock()
@@ -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()
 	defer metadata.bundleHeadHashMutex.RUnlock()
 
 	return metadata.bundleHeadHash
 }
 
-func (metadata *TransactionMetadata) SetBundleHeadHash(bundleTailHash ternary.Trytes) {
+func (metadata *TransactionMetadata) SetBundleHeadHash(bundleTailHash trinary.Trytes) {
 	metadata.bundleHeadHashMutex.RLock()
 	if metadata.bundleHeadHash != bundleTailHash {
 		metadata.bundleHeadHashMutex.RUnlock()
@@ -218,7 +219,7 @@ func (metadata *TransactionMetadata) Marshal() ([]byte, errors.IdentifiableError
 	metadata.finalizedMutex.RLock()
 	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()
 	if err != nil {
@@ -253,7 +254,7 @@ func (metadata *TransactionMetadata) Unmarshal(data []byte) errors.IdentifiableE
 	metadata.finalizedMutex.Lock()
 	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 {
 		return ErrUnmarshalFailed.Derive(err, "could not unmarshal the received time")

packages/model/value_transaction/constants.go

@@ -3,7 +3,7 @@ package value_transaction
 import (
 	"strings"
 
-	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/iota.go/trinary"
 )
 
 const (
@@ -30,5 +30,5 @@ const (
 )
 
 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))
 )

packages/model/value_transaction/value_transaction.go

@@ -4,24 +4,24 @@ import (
 	"sync"
 
 	"github.com/iotaledger/goshimmer/packages/model/meta_transaction"
-	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/iota.go/trinary"
 )
 
 type ValueTransaction struct {
 	*meta_transaction.MetaTransaction
 
-	address                       *ternary.Trytes
+	address                       *trinary.Trytes
 	addressMutex                  sync.RWMutex
 	value                         *int64
 	valueMutex                    sync.RWMutex
 	timestamp                     *uint
 	timestampMutex                sync.RWMutex
-	nonce                         *ternary.Trytes
+	nonce                         *trinary.Trytes
 	nonceMutex                    sync.RWMutex
-	signatureMessageFragment      *ternary.Trytes
+	signatureMessageFragment      *trinary.Trytes
 	signatureMessageFragmentMutex sync.RWMutex
 
-	trits ternary.Trits
+	trits trinary.Trits
 }
 
 func New() (result *ValueTransaction) {
@@ -42,8 +42,13 @@ func FromMetaTransaction(metaTransaction *meta_transaction.MetaTransaction) *Val
 }
 
 func FromBytes(bytes []byte) (result *ValueTransaction) {
+	trits, err := trinary.BytesToTrits(bytes)
+	if err != nil {
+		panic(err)
+	}
+
 	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()
@@ -52,14 +57,14 @@ func FromBytes(bytes []byte) (result *ValueTransaction) {
 }
 
 // getter for the address (supports concurrency)
-func (this *ValueTransaction) GetAddress() (result ternary.Trytes) {
+func (this *ValueTransaction) GetAddress() (result trinary.Trytes) {
 	this.addressMutex.RLock()
 	if this.address == nil {
 		this.addressMutex.RUnlock()
 		this.addressMutex.Lock()
 		defer this.addressMutex.Unlock()
 		if this.address == nil {
-			address := this.trits[ADDRESS_OFFSET:ADDRESS_END].ToTrytes()
+			address := trinary.MustTritsToTrytes(this.trits[ADDRESS_OFFSET:ADDRESS_END])
 
 			this.address = &address
 		}
@@ -73,7 +78,7 @@ func (this *ValueTransaction) GetAddress() (result ternary.Trytes) {
 }
 
 // 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()
 	if this.address == nil || *this.address != address {
 		this.addressMutex.RUnlock()
@@ -83,7 +88,7 @@ func (this *ValueTransaction) SetAddress(address ternary.Trytes) bool {
 			this.address = &address
 
 			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.SetModified(true)
@@ -106,7 +111,7 @@ func (this *ValueTransaction) GetValue() (result int64) {
 		this.valueMutex.Lock()
 		defer this.valueMutex.Unlock()
 		if this.value == nil {
-			value := this.trits[VALUE_OFFSET:VALUE_END].ToInt64()
+			value := trinary.TritsToInt(this.trits[VALUE_OFFSET:VALUE_END])
 
 			this.value = &value
 		}
@@ -130,7 +135,7 @@ func (this *ValueTransaction) SetValue(value int64) bool {
 			this.value = &value
 
 			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.SetModified(true)
@@ -153,7 +158,7 @@ func (this *ValueTransaction) GetTimestamp() (result uint) {
 		this.timestampMutex.Lock()
 		defer this.timestampMutex.Unlock()
 		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
 		}
@@ -177,7 +182,7 @@ func (this *ValueTransaction) SetTimestamp(timestamp uint) bool {
 			this.timestamp = &timestamp
 
 			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.SetModified(true)
@@ -192,12 +197,12 @@ func (this *ValueTransaction) SetTimestamp(timestamp uint) bool {
 	return false
 }
 
-func (this *ValueTransaction) GetBundleEssence() (result ternary.Trits) {
+func (this *ValueTransaction) GetBundleEssence() (result trinary.Trits) {
 	this.addressMutex.RLock()
 	this.valueMutex.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])
 
@@ -213,14 +218,14 @@ func (this *ValueTransaction) GetBundleEssence() (result ternary.Trits) {
 }
 
 // getter for the nonce (supports concurrency)
-func (this *ValueTransaction) GetNonce() (result ternary.Trytes) {
+func (this *ValueTransaction) GetNonce() (result trinary.Trytes) {
 	this.nonceMutex.RLock()
 	if this.nonce == nil {
 		this.nonceMutex.RUnlock()
 		this.nonceMutex.Lock()
 		defer this.nonceMutex.Unlock()
 		if this.nonce == nil {
-			nonce := this.trits[NONCE_OFFSET:NONCE_END].ToTrytes()
+			nonce := trinary.MustTritsToTrytes(this.trits[NONCE_OFFSET:NONCE_END])
 
 			this.nonce = &nonce
 		}
@@ -234,7 +239,7 @@ func (this *ValueTransaction) GetNonce() (result ternary.Trytes) {
 }
 
 // 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()
 	if this.nonce == nil || *this.nonce != nonce {
 		this.nonceMutex.RUnlock()
@@ -244,7 +249,7 @@ func (this *ValueTransaction) SetNonce(nonce ternary.Trytes) bool {
 			this.nonce = &nonce
 
 			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.SetModified(true)
@@ -260,14 +265,14 @@ func (this *ValueTransaction) SetNonce(nonce ternary.Trytes) bool {
 }
 
 // getter for the signatureMessageFragmetn (supports concurrency)
-func (this *ValueTransaction) GetSignatureMessageFragment() (result ternary.Trytes) {
+func (this *ValueTransaction) GetSignatureMessageFragment() (result trinary.Trytes) {
 	this.signatureMessageFragmentMutex.RLock()
 	if this.signatureMessageFragment == nil {
 		this.signatureMessageFragmentMutex.RUnlock()
 		this.signatureMessageFragmentMutex.Lock()
 		defer this.signatureMessageFragmentMutex.Unlock()
 		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
 		}
@@ -281,7 +286,7 @@ func (this *ValueTransaction) GetSignatureMessageFragment() (result ternary.Tryt
 }
 
 // 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()
 	if this.signatureMessageFragment == nil || *this.signatureMessageFragment != signatureMessageFragment {
 		this.signatureMessageFragmentMutex.RUnlock()
@@ -291,7 +296,7 @@ func (this *ValueTransaction) SetSignatureMessageFragment(signatureMessageFragme
 			this.signatureMessageFragment = &signatureMessageFragment
 
 			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.SetModified(true)

packages/model/value_transaction/value_transaction_test.go

@@ -4,12 +4,12 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/iotaledger/goshimmer/packages/ternary"
+	"github.com/iotaledger/iota.go/trinary"
 	"github.com/magiconair/properties/assert"
 )
 
 func TestValueTransaction_SettersGetters(t *testing.T) {
-	address := ternary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
+	address := trinary.Trytes("A9999999999999999999999999999999999999999999999999999999999999999999999999999999F")
 
 	transaction := New()
 	transaction.SetAddress(address)

packages/ternary/bc_ternary_demultiplexer.go

 package ternary
 
+import (
+	. "github.com/iotaledger/iota.go/trinary"
+)
+
 type BCTernaryDemultiplexer struct {
 	bcTrits BCTrits
 }