Can't seem to avoid checksum failure about go_kraken HOT 2 CLOSED

package main

import (
	"fmt"
	"hash/crc32"
	"sort"
	"strings"

	ws "github.com/aopoltorzhicky/go_kraken/websocket"
	"github.com/pkg/errors"
	"github.com/shopspring/decimal"
)

// OrderBook -
type OrderBook struct {
	Asks map[string]string
	Bids map[string]string

	sortedAsks []Level
	sortedBids []Level

	depth int
}

// NewOrderBook -
func NewOrderBook(depth int) *OrderBook {
	return &OrderBook{
		Asks: make(map[string]string),
		Bids: make(map[string]string),

		sortedAsks: make([]Level, 0),
		sortedBids: make([]Level, 0),

		depth: depth,
	}
}

// String -
func (o *OrderBook) String() string {
	var str strings.Builder

	str.WriteString("asks:\r\n")
	for price, vol := range o.Asks {
		str.WriteString("\t" + price)
		str.WriteByte('[')
		str.WriteString(vol)
		str.WriteString("]\r\n")
	}

	str.WriteString("bids:\r\n")
	for price, vol := range o.Bids {
		str.WriteString("\t" + price)
		str.WriteByte('[')
		str.WriteString(vol)
		str.WriteString("]\r\n")
	}

	return str.String()
}

func (o *OrderBook) update(m map[string]string, upd ws.OrderBookItem) error {
	flVolume, err := upd.Volume.Float64()
	if err != nil {
		return err
	}
	price := upd.Price.String()

	if flVolume == 0 {
		delete(m, price)
	} else {
		m[price] = upd.Volume.String()
	}

	return nil
}

// Update -
func (o *OrderBook) Update(upd ws.OrderBookUpdate, withCheckSum bool) error {
	for i := range upd.Asks {
		if err := o.update(o.Asks, upd.Asks[i]); err != nil {
			return err
		}
	}

	o.sortedAsks = orderMap(o.Asks, true)[:o.depth]

	for price := range o.Asks {
		var found bool
		for i := range o.sortedAsks {
			if o.sortedAsks[i].Price == price {
				found = true
				break
			}
		}

		if !found {
			delete(o.Asks, price)
		}
	}

	for i := range upd.Bids {
		if err := o.update(o.Bids, upd.Bids[i]); err != nil {
			return err
		}
	}

	o.sortedBids = orderMap(o.Bids, false)[:o.depth]

	for price := range o.Bids {
		var found bool
		for i := range o.sortedBids {
			if o.sortedBids[i].Price == price {
				found = true
				break
			}
		}

		if !found {
			delete(o.Bids, price)
		}
	}

	if withCheckSum && !upd.IsSnapshot {
		cs := o.CheckSum()
		if cs != upd.CheckSum {
			return errors.Errorf("invalid checksum: %s != %s", cs, upd.CheckSum)
		}
	}

	return nil
}

// CheckSum -
func (o *OrderBook) CheckSum() string {
	var str strings.Builder

	for _, level := range o.sortedAsks {
		price := decimal.RequireFromString(level.Price).StringFixed(5)
		price = strings.Replace(price, ".", "", 1)
		price = strings.TrimLeft(price, "0")
		str.WriteString(price)

		volume := decimal.RequireFromString(level.Volume).StringFixed(8)
		volume = strings.Replace(volume, ".", "", 1)
		volume = strings.TrimLeft(volume, "0")
		str.WriteString(volume)
	}

	for _, level := range o.sortedBids {
		price := decimal.RequireFromString(level.Price).StringFixed(5)
		price = strings.Replace(price, ".", "", 1)
		price = strings.TrimLeft(price, "0")
		str.WriteString(price)

		volume := decimal.RequireFromString(level.Volume).StringFixed(8)
		volume = strings.Replace(volume, ".", "", 1)
		volume = strings.TrimLeft(volume, "0")
		str.WriteString(volume)
	}

	checksum := str.String()
	checksumInt := crc32.ChecksumIEEE([]byte(checksum))

	return fmt.Sprint(checksumInt)
}

type Level struct {
	Price  string
	Volume string
}

type ByPrice []Level

func (a ByPrice) Len() int           { return len(a) }
func (a ByPrice) Less(i, j int) bool { return a[i].Price < a[j].Price }
func (a ByPrice) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

func orderMap(m map[string]string, asc bool) []Level {
	result := make([]Level, 0)

	for key, value := range m {
		result = append(result, Level{key, value})
	}

	if asc {
		sort.Sort(ByPrice(result))
	} else {
		sort.Sort(sort.Reverse(ByPrice(result)))
	}

	return result
}