Merge pull request #173 from xssnick/dev-v19

v1.9

.github/workflows/go.yml

@@ -43,7 +43,7 @@ jobs:
  filename: coverage.out
 
  - name: Verify Changed files
- uses: tj-actions/verify-changed-files@v9.1
+ uses: tj-actions/verify-changed-files@v17
  id: verify-changed-files
  with:
  files: README.md

README.md

@@ -3,7 +3,7 @@
 <img align="right" width="425px" src="https://github.com/xssnick/props/blob/master/logoimg.png?raw=true">
 
 [![Based on TON][ton-svg]][ton]
-![Coverage](https://img.shields.io/badge/Coverage-73.3%25-brightgreen)
+![Coverage](https://img.shields.io/badge/Coverage-74.3%25-brightgreen)
 
 Golang library for interacting with TON blockchain.
 

address/addr.go

@@ -3,6 +3,7 @@ package address
 import (
  "encoding/base64"
  "encoding/binary"
+ "encoding/hex"
  "errors"
  "fmt"
 
@@ -93,10 +94,22 @@ func (a *Address) String() string {
  binary.BigEndian.PutUint16(address[34:], crc16.Checksum(address[:34], crcTable))
  return base64.RawURLEncoding.EncodeToString(address[:])
  case ExtAddress:
- // TODO support readable serialization
- return "EXT_ADDRESS"
+ address := make([]byte, 1+4+len(a.data))
+
+ address[0] = a.FlagsToByte()
+ binary.BigEndian.PutUint32(address[1:], uint32(a.bitsLen))
+ copy(address[5:], a.data)
+
+ return fmt.Sprintf("EXT:%s", hex.EncodeToString(address))
  case VarAddress:
- return "VAR_ADDRESS"
+ address := make([]byte, 1+4+4+len(a.data))
+
+ address[0] = a.FlagsToByte()
+ binary.BigEndian.PutUint32(address[1:], uint32(a.workchain))
+ binary.BigEndian.PutUint32(address[5:], uint32(a.bitsLen))
+ copy(address[9:], a.data)
+
+ return fmt.Sprintf("VAR:%s", hex.EncodeToString(address))
  default:
  return "NOT_SUPPORTED"
  }
@@ -128,6 +141,63 @@ func (a *Address) MarshalJSON() ([]byte, error) {
  return []byte(fmt.Sprintf("%q", a.String())), nil
 }
 
+func (a *Address) UnmarshalJSON(data []byte) error {
+ if len(data) < 2 || data[0] != '"' || data[len(data)-1] != '"' {
+ return fmt.Errorf("invalid data")
+ }
+
+ data = data[1 : len(data)-1]
+ strData := string(data)
+
+ var (
+ addr *Address
+ err error
+ )
+
+ if strData == "NONE" {
+ addr = NewAddressNone()
+ } else if strData == "NOT_SUPPORTED" {
+ return fmt.Errorf("not supported address")
+ } else if len(strData) >= 9 && strData[:4] == "EXT:" {
+ strData = strData[4:]
+
+ b, err := hex.DecodeString(strData)
+ if err != nil {
+ return err
+ }
+
+ addr = NewAddressExt(
+ b[0],
+ uint(binary.BigEndian.Uint32(b[1:5])),
+ b[5:],
+ )
+
+ } else if len(strData) >= 13 && strData[:4] == "VAR:" {
+ strData = strData[4:]
+
+ b, err := hex.DecodeString(strData)
+ if err != nil {
+ return err
+ }
+
+ addr = NewAddressVar(
+ b[0],
+ int32(binary.BigEndian.Uint32(b[1:5])),
+ uint(binary.BigEndian.Uint32(b[5:9])),
+ b[9:],
+ )
+ } else {
+ addr, err = ParseAddr(strData)
+ if err != nil {
+ return err
+ }
+ }
+
+ *a = *addr
+
+ return nil
+}
+
 func MustParseAddr(addr string) *Address {
  a, err := ParseAddr(addr)
  if err != nil {

address/addr_test.go

@@ -461,3 +461,229 @@ func TestParseflags(t *testing.T) {
  })
  }
 }
+
+func TestAddress_MarshalJSON(t *testing.T) {
+ tests := []struct {
+ name string
+ address *Address
+ want string
+ wantErr bool
+ }{
+ {
+ name: "none",
+ address: NewAddressNone(),
+ want: "\"NONE\"",
+ wantErr: false,
+ },
+ {
+ name: "std address",
+ address: MustParseAddr("EQCTDVUzmAq6EfzYGEWpVOv16yo-H5Vw3B0rktcidz_ULOUj"),
+ want: "\"EQCTDVUzmAq6EfzYGEWpVOv16yo-H5Vw3B0rktcidz_ULOUj\"",
+ wantErr: false,
+ },
+ {
+ name: "ext address",
+ address: &Address{
+ flags: flags{
+ bounceable: true,
+ testnet: false,
+ },
+ addrType: ExtAddress,
+ workchain: 0,
+ bitsLen: 256,
+ data: []byte{1, 2, 3},
+ },
+ want: "\"EXT:1100000100010203\"",
+ wantErr: false,
+ },
+ {
+ name: "ext address with empty data",
+ address: &Address{
+ flags: flags{
+ bounceable: true,
+ testnet: false,
+ },
+ addrType: ExtAddress,
+ workchain: 0,
+ bitsLen: 256,
+ data: nil,
+ },
+ want: "\"EXT:1100000100\"",
+ wantErr: false,
+ },
+ {
+ name: "var address",
+ address: &Address{
+ flags: flags{
+ bounceable: true,
+ testnet: true,
+ },
+ addrType: VarAddress,
+ workchain: -1,
+ bitsLen: 256,
+ data: []byte{4, 5, 6},
+ },
+ want: "\"VAR:91ffffffff00000100040506\"",
+ wantErr: false,
+ },
+ {
+ name: "var address with empty data",
+ address: &Address{
+ flags: flags{
+ bounceable: true,
+ testnet: true,
+ },
+ addrType: VarAddress,
+ workchain: -1,
+ bitsLen: 256,
+ data: nil,
+ },
+ want: "\"VAR:91ffffffff00000100\"",
+ wantErr: false,
+ },
+ {
+ name: "not supported type",
+ address: &Address{addrType: 5},
+ want: "\"NOT_SUPPORTED\"",
+ wantErr: false,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got, err := tt.address.MarshalJSON()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("MarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+
+ wantBytes := []byte(tt.want)
+ if !reflect.DeepEqual(got, wantBytes) {
+ t.Errorf("MarshalJSON() got = %v, want %v", string(got), tt.want)
+ }
+ })
+ }
+}
+
+func TestAddress_UnmarshalJSON(t *testing.T) {
+ tests := []struct {
+ name string
+ address string
+ want Address
+ wantErr bool
+ }{
+ {
+ name: "invalid empty",
+ address: "",
+ want: Address{},
+ wantErr: true,
+ },
+ {
+ name: "empty",
+ address: "\"\"",
+ want: Address{},
+ wantErr: true,
+ },
+ {
+ name: "valid",
+ address: "\"EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I\"",
+ want: Address{
+ addrType: StdAddress,
+ bitsLen: 256,
+ flags: flags{bounceable: true, testnet: false},
+ workchain: 0,
+ data: []byte{186, 41, 94, 51, 179, 196, 201, 181, 38, 90, 164, 234, 209, 22, 106, 146, 147, 28, 233, 171, 234, 18, 10, 140, 94, 145, 4, 74, 18, 87, 248, 156},
+ },
+ wantErr: false,
+ },
+ {
+ name: "invalid",
+ address: "\"AQCTDVUzmAq6EfzYGEWpVOv16yo-H5Vw3B0rktcidz_ULOUj\"",
+ want: Address{},
+ wantErr: true,
+ },
+ {
+ name: "none address",
+ address: "\"NONE\"",
+ want: Address{
+ addrType: NoneAddress,
+ },
+ wantErr: false,
+ },
+ {
+ name: "ext address",
+ address: "\"EXT:1100000100010203\"",
+ want: Address{
+ flags: flags{
+ bounceable: true,
+ testnet: false,
+ },
+ addrType: ExtAddress,
+ workchain: 0,
+ bitsLen: 256,
+ data: []byte{1, 2, 3},
+ },
+ wantErr: false,
+ },
+ {
+ name: "ext address with empty data",
+ address: "\"EXT:1100000100\"",
+ want: Address{
+ flags: flags{
+ bounceable: true,
+ testnet: false,
+ },
+ addrType: ExtAddress,
+ workchain: 0,
+ bitsLen: 256,
+ data: []byte{},
+ },
+ wantErr: false,
+ },
+ {
+ name: "var address",
+ address: "\"VAR:91ffffffff00000100040506\"",
+ want: Address{
+ flags: flags{
+ bounceable: true,
+ testnet: true,
+ },
+ addrType: VarAddress,
+ workchain: -1,
+ bitsLen: 256,
+ data: []byte{4, 5, 6},
+ },
+ wantErr: false,
+ },
+ {
+ name: "var address with empty data",
+ address: "\"VAR:91ffffffff00000100\"",
+ want: Address{
+ flags: flags{
+ bounceable: true,
+ testnet: true,
+ },
+ addrType: VarAddress,
+ workchain: -1,
+ bitsLen: 256,
+ data: []byte{},
+ },
+ wantErr: false,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ var a Address
+
+ err := a.UnmarshalJSON([]byte(tt.address))
+ if (err != nil) != tt.wantErr {
+ t.Errorf("UnmarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
+ }
+
+ if !reflect.DeepEqual(a, tt.want) {
+ t.Errorf("UnmarshalJSON() got = %v, want %v", a, tt.want)
+ }
+ })
+ }
+}