diff --git a/base58/README.md b/base58/README.md
new file mode 100644
index 0000000..043da74
--- /dev/null
+++ b/base58/README.md
@@ -0,0 +1,37 @@
+base58
+==========
+
+[![Build Status](https://travis-ci.org/conformal/btcutil.png?branch=master)]
+(https://travis-ci.org/conformal/btcutil)
+
+Package base58 provides an API for for encoding and decoding to and from the base58 encoding.
+It also provides an API to do base58Check encoding, as described [here](https://en.bitcoin.it/wiki/Base58Check_encoding). 
+
+A comprehensive suite of tests is provided to ensure proper functionality.  See
+`test_coverage.txt` for the gocov coverage report.  Alternatively, if you are
+running a POSIX OS, you can run the `cov_report.sh` script for a real-time
+report.  Package base58 is licensed under the liberal ISC license.
+
+## Documentation
+
+[![GoDoc](https://godoc.org/github.com/conformal/btcutil/base58?status.png)]
+(http://godoc.org/github.com/conformal/btcutil/base58)
+
+Full `go doc` style documentation for the project can be viewed online without
+installing this package by using the GoDoc site here:
+http://godoc.org/github.com/conformal/btcutil/base58
+
+You can also view the documentation locally once the package is installed with
+the `godoc` tool by running `godoc -http=":6060"` and pointing your browser to
+http://localhost:6060/pkg/github.com/conformal/btcutil/base58
+
+## Installation
+
+```bash
+$ go get github.com/conformal/btcutil/base58
+```
+
+## License
+
+Package base58 is licensed under the [copyfree](http://copyfree.org) ISC
+License.
diff --git a/base58/base58.go b/base58/base58.go
new file mode 100644
index 0000000..fc4318f
--- /dev/null
+++ b/base58/base58.go
@@ -0,0 +1,78 @@
+// Copyright (c) 2013-2014 Conformal Systems LLC.
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package base58
+
+import (
+	"math/big"
+	"strings"
+)
+
+// alphabet is the modified base58 alphabet used by Bitcoin.
+const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+var bigRadix = big.NewInt(58)
+var bigZero = big.NewInt(0)
+
+// Decode decodes a modified base58 string to a byte slice.
+func Decode(b string) []byte {
+	answer := big.NewInt(0)
+	j := big.NewInt(1)
+
+	for i := len(b) - 1; i >= 0; i-- {
+		tmp := strings.IndexAny(alphabet, string(b[i]))
+		if tmp == -1 {
+			return []byte("")
+		}
+		idx := big.NewInt(int64(tmp))
+		tmp1 := big.NewInt(0)
+		tmp1.Mul(j, idx)
+
+		answer.Add(answer, tmp1)
+		j.Mul(j, bigRadix)
+	}
+
+	tmpval := answer.Bytes()
+
+	var numZeros int
+	for numZeros = 0; numZeros < len(b); numZeros++ {
+		if b[numZeros] != alphabet[0] {
+			break
+		}
+	}
+	flen := numZeros + len(tmpval)
+	val := make([]byte, flen, flen)
+	copy(val[numZeros:], tmpval)
+
+	return val
+}
+
+// Encode encodes a byte slice to a modified base58 string.
+func Encode(b []byte) string {
+	x := new(big.Int)
+	x.SetBytes(b)
+
+	answer := make([]byte, 0, len(b)*136/100)
+	for x.Cmp(bigZero) > 0 {
+		mod := new(big.Int)
+		x.DivMod(x, bigRadix, mod)
+		answer = append(answer, alphabet[mod.Int64()])
+	}
+
+	// leading zero bytes
+	for _, i := range b {
+		if i != 0 {
+			break
+		}
+		answer = append(answer, alphabet[0])
+	}
+
+	// reverse
+	alen := len(answer)
+	for i := 0; i < alen/2; i++ {
+		answer[i], answer[alen-1-i] = answer[alen-1-i], answer[i]
+	}
+
+	return string(answer)
+}
diff --git a/base58/base58_check.go b/base58/base58_check.go
new file mode 100644
index 0000000..063fa26
--- /dev/null
+++ b/base58/base58_check.go
@@ -0,0 +1,52 @@
+// Copyright (c) 2013-2014 Conformal Systems LLC.
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package base58
+
+import (
+	"crypto/sha256"
+	"errors"
+)
+
+// ErrChecksum indicates that the checksum of a check-encoded string does not verify against
+// the checksum.
+var ErrChecksum = errors.New("checksum error")
+
+// ErrInvalidFormat indicates that the check-encoded string has an invalid format.
+var ErrInvalidFormat = errors.New("invalid format: version and/or checksum bytes missing")
+
+// checksum: first four bytes of sha256^2
+func checksum(input []byte) (cksum [4]byte) {
+	h := sha256.Sum256(input)
+	h2 := sha256.Sum256(h[:])
+	copy(cksum[:], h2[:4])
+	return
+}
+
+// CheckEncode prepends a version byte and appends a four byte checksum.
+func CheckEncode(input []byte, version byte) string {
+	b := make([]byte, 0, 1+len(input)+4)
+	b = append(b, version)
+	b = append(b, input[:]...)
+	cksum := checksum(b)
+	b = append(b, cksum[:]...)
+	return Encode(b)
+}
+
+// CheckDecode decodes a string that was encoded with CheckEncode and verifies the checksum.
+func CheckDecode(input string) (result []byte, version byte, err error) {
+	decoded := Decode(input)
+	if len(decoded) < 5 {
+		return nil, 0, ErrInvalidFormat
+	}
+	version = decoded[0]
+	var cksum [4]byte
+	copy(cksum[:], decoded[len(decoded)-4:])
+	if checksum(decoded[:len(decoded)-4]) != cksum {
+		return nil, 0, ErrChecksum
+	}
+	payload := decoded[1 : len(decoded)-4]
+	result = append(result, payload...)
+	return
+}
diff --git a/base58/base58_check_test.go b/base58/base58_check_test.go
new file mode 100644
index 0000000..ce32c4c
--- /dev/null
+++ b/base58/base58_check_test.go
@@ -0,0 +1,66 @@
+// Copyright (c) 2013-2014 Conformal Systems LLC.
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package base58_test
+
+import (
+	"testing"
+
+	"github.com/conformal/btcutil/base58"
+)
+
+var checkEncodingStringTests = []struct {
+	version byte
+	in      string
+	out     string
+}{
+	{20, "", "3MNQE1X"},
+	{20, " ", "B2Kr6dBE"},
+	{20, "-", "B3jv1Aft"},
+	{20, "0", "B482yuaX"},
+	{20, "1", "B4CmeGAC"},
+	{20, "-1", "mM7eUf6kB"},
+	{20, "11", "mP7BMTDVH"},
+	{20, "abc", "4QiVtDjUdeq"},
+	{20, "1234598760", "ZmNb8uQn5zvnUohNCEPP"},
+	{20, "abcdefghijklmnopqrstuvwxyz", "K2RYDcKfupxwXdWhSAxQPCeiULntKm63UXyx5MvEH2"},
+	{20, "00000000000000000000000000000000000000000000000000000000000000", "bi1EWXwJay2udZVxLJozuTb8Meg4W9c6xnmJaRDjg6pri5MBAxb9XwrpQXbtnqEoRV5U2pixnFfwyXC8tRAVC8XxnjK"},
+}
+
+func TestBase58Check(t *testing.T) {
+	for x, test := range checkEncodingStringTests {
+		// test encoding
+		if res := base58.CheckEncode([]byte(test.in), test.version); res != test.out {
+			t.Errorf("CheckEncode test #%d failed: got %s, want: %s", x, res, test.out)
+		}
+
+		// test decoding
+		res, version, err := base58.CheckDecode(test.out)
+		if err != nil {
+			t.Errorf("CheckDecode test #%d failed with err: %v", x, err)
+		} else if version != test.version {
+			t.Errorf("CheckDecode test #%d failed: got version: %d want: %d", x, version, test.version)
+		} else if string(res) != test.in {
+			t.Errorf("CheckDecode test #%d failed: got: %s want: %s", x, res, test.in)
+		}
+	}
+
+	// test the two decoding failure cases
+	// case 1: checksum error
+	_, _, err := base58.CheckDecode("3MNQE1Y")
+	if err != base58.ErrChecksum {
+		t.Error("Checkdecode test failed, expected ErrChecksum")
+	}
+	// case 2: invalid formats (string lengths below 5 mean the version byte and/or the checksum
+	// bytes are missing).
+	testString := ""
+	for len := 0; len < 4; len++ {
+		// make a string of length `len`
+		_, _, err = base58.CheckDecode(testString)
+		if err != base58.ErrInvalidFormat {
+			t.Error("Checkdecode test failed, expected ErrInvalidFormat")
+		}
+	}
+
+}
diff --git a/base58/base58_test.go b/base58/base58_test.go
new file mode 100644
index 0000000..4669077
--- /dev/null
+++ b/base58/base58_test.go
@@ -0,0 +1,98 @@
+// Copyright (c) 2013-2014 Conformal Systems LLC.
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package base58_test
+
+import (
+	"bytes"
+	"encoding/hex"
+	"testing"
+
+	"github.com/conformal/btcutil/base58"
+)
+
+var stringTests = []struct {
+	in  string
+	out string
+}{
+	{"", ""},
+	{" ", "Z"},
+	{"-", "n"},
+	{"0", "q"},
+	{"1", "r"},
+	{"-1", "4SU"},
+	{"11", "4k8"},
+	{"abc", "ZiCa"},
+	{"1234598760", "3mJr7AoUXx2Wqd"},
+	{"abcdefghijklmnopqrstuvwxyz", "3yxU3u1igY8WkgtjK92fbJQCd4BZiiT1v25f"},
+	{"00000000000000000000000000000000000000000000000000000000000000", "3sN2THZeE9Eh9eYrwkvZqNstbHGvrxSAM7gXUXvyFQP8XvQLUqNCS27icwUeDT7ckHm4FUHM2mTVh1vbLmk7y"},
+}
+
+var invalidStringTests = []struct {
+	in  string
+	out string
+}{
+	{"0", ""},
+	{"O", ""},
+	{"I", ""},
+	{"l", ""},
+	{"3mJr0", ""},
+	{"O3yxU", ""},
+	{"3sNI", ""},
+	{"4kl8", ""},
+	{"0OIl", ""},
+	{"!@#$%^&*()-_=+~`", ""},
+}
+
+var hexTests = []struct {
+	in  string
+	out string
+}{
+	{"61", "2g"},
+	{"626262", "a3gV"},
+	{"636363", "aPEr"},
+	{"73696d706c792061206c6f6e6720737472696e67", "2cFupjhnEsSn59qHXstmK2ffpLv2"},
+	{"00eb15231dfceb60925886b67d065299925915aeb172c06647", "1NS17iag9jJgTHD1VXjvLCEnZuQ3rJDE9L"},
+	{"516b6fcd0f", "ABnLTmg"},
+	{"bf4f89001e670274dd", "3SEo3LWLoPntC"},
+	{"572e4794", "3EFU7m"},
+	{"ecac89cad93923c02321", "EJDM8drfXA6uyA"},
+	{"10c8511e", "Rt5zm"},
+	{"00000000000000000000", "1111111111"},
+}
+
+func TestBase58(t *testing.T) {
+	// Base58Encode tests
+	for x, test := range stringTests {
+		tmp := []byte(test.in)
+		if res := base58.Encode(tmp); res != test.out {
+			t.Errorf("Encode test #%d failed: got: %s want: %s",
+				x, res, test.out)
+			continue
+		}
+	}
+
+	// Base58Decode tests
+	for x, test := range hexTests {
+		b, err := hex.DecodeString(test.in)
+		if err != nil {
+			t.Errorf("hex.DecodeString failed failed #%d: got: %s", x, test.in)
+			continue
+		}
+		if res := base58.Decode(test.out); bytes.Equal(res, b) != true {
+			t.Errorf("Decode test #%d failed: got: %q want: %q",
+				x, res, test.in)
+			continue
+		}
+	}
+
+	// Base58Decode with invalid input
+	for x, test := range invalidStringTests {
+		if res := base58.Decode(test.in); string(res) != test.out {
+			t.Errorf("Decode invalidString test #%d failed: got: %q want: %q",
+				x, res, test.out)
+			continue
+		}
+	}
+}
diff --git a/base58/cov_report.sh b/base58/cov_report.sh
new file mode 100644
index 0000000..307f05b
--- /dev/null
+++ b/base58/cov_report.sh
@@ -0,0 +1,17 @@
+#!/bin/sh
+
+# This script uses gocov to generate a test coverage report.
+# The gocov tool my be obtained with the following command:
+#   go get github.com/axw/gocov/gocov
+#
+# It will be installed to $GOPATH/bin, so ensure that location is in your $PATH.
+
+# Check for gocov.
+type gocov >/dev/null 2>&1
+if [ $? -ne 0 ]; then
+	echo >&2 "This script requires the gocov tool."
+	echo >&2 "You may obtain it with the following command:"
+	echo >&2 "go get github.com/axw/gocov/gocov"
+	exit 1
+fi
+gocov test | gocov report