status-im/status-go

package generator

import (
    "fmt"
    "io"
    "strconv"
    "strings"
)

type startingPoint int

const (
    tokenMaster    = 0x6D // char m
    tokenSeparator = 0x2F // char /
    tokenHardened  = 0x27 // char '
    tokenDot       = 0x2E // char .

    hardenedStart = 0x80000000 // 2^31
)

const (
    startingPointMaster startingPoint = iota + 1
    startingPointCurrent
    startingPointParent
)

type parseFunc = func() error

type pathDecoder struct {
    s                    string
    r                    *strings.Reader
    f                    parseFunc
    pos                  int
    path                 []uint32
    start                startingPoint
    currentToken         string
    currentTokenHardened bool
}

func newPathDecoder(path string) (*pathDecoder, error) {
    d := &pathDecoder{
        s: path,
        r: strings.NewReader(path),
    }

    if err := d.reset(); err != nil {
        return nil, err
    }

    return d, nil
}

func (d *pathDecoder) reset() error {
    _, err := d.r.Seek(0, io.SeekStart)
    if err != nil {
        return err
    }

    d.pos = 0
    d.start = startingPointCurrent
    d.f = d.parseStart
    d.path = make([]uint32, 0)
    d.resetCurrentToken()

    return nil
}

func (d *pathDecoder) resetCurrentToken() {
    d.currentToken = ""
    d.currentTokenHardened = false
}

func (d *pathDecoder) parse() (startingPoint, []uint32, error) {
    for {
        err := d.f()
        if err != nil {
            if err == io.EOF {
                err = nil
            } else {
                err = fmt.Errorf("error parsing derivation path %s; at position %d, %s", d.s, d.pos, err.Error())
            }

            return d.start, d.path, err
        }
    }
}

func (d *pathDecoder) readByte() (byte, error) {
    b, err := d.r.ReadByte()
    if err != nil {
        return b, err
    }

    d.pos++

    return b, nil
}

func (d *pathDecoder) unreadByte() error {
    err := d.r.UnreadByte()
    if err != nil {
        return err
    }

    d.pos--

    return nil
}

func (d *pathDecoder) parseStart() error {
    b, err := d.readByte()
    if err != nil {
        return err
    }

    if b == tokenMaster {
        d.start = startingPointMaster
        d.f = d.parseSeparator
        return nil
    }

    if b == tokenDot {
        b2, err := d.readByte()
        if err != nil {
            return err
        }

        if b2 == tokenDot {
            d.f = d.parseSeparator
            d.start = startingPointParent
            return nil
        }

        d.f = d.parseSeparator
        d.start = startingPointCurrent
        return d.unreadByte()
    }

    d.f = d.parseSegment

    return d.unreadByte()
}

func (d *pathDecoder) saveSegment() error {
    if len(d.currentToken) > 0 {
        i, err := strconv.ParseUint(d.currentToken, 10, 32)
        if err != nil {
            return err
        }

        if i >= hardenedStart {
            d.pos -= len(d.currentToken) - 1
            return fmt.Errorf("index must be lower than 2^31, got %d", i)
        }

        if d.currentTokenHardened {
            i += hardenedStart
        }

        d.path = append(d.path, uint32(i))
    }

    d.f = d.parseSegment
    d.resetCurrentToken()

    return nil
}

func (d *pathDecoder) parseSeparator() error {
    b, err := d.readByte()
    if err != nil {
        return err
    }

    if b == tokenSeparator {
        return d.saveSegment()
    }

    return fmt.Errorf("expected %s, got %s", string(rune(tokenSeparator)), string(rune(b)))
}

func (d *pathDecoder) parseSegment() error {
    b, err := d.readByte()
    if err == io.EOF {
        if len(d.currentToken) == 0 {
            return fmt.Errorf("expected number, got EOF")
        }

        if newErr := d.saveSegment(); newErr != nil {
            return newErr
        }

        return err
    }

    if err != nil {
        return err
    }

    if len(d.currentToken) > 0 && b == tokenSeparator {
        return d.saveSegment()
    }

    if len(d.currentToken) > 0 && b == tokenHardened {
        d.currentTokenHardened = true
        d.f = d.parseSeparator
        return nil
    }

    if b < 0x30 || b > 0x39 {
        return fmt.Errorf("expected number, got %s", string(b))
    }

    d.currentToken = fmt.Sprintf("%s%s", d.currentToken, string(b))

    return nil
}

func decodePath(str string) (startingPoint, []uint32, error) {
    d, err := newPathDecoder(str)
    if err != nil {
        return 0, nil, err
    }

    return d.parse()
}