support denoms custom validation

types/coin.go

@@ -599,15 +599,33 @@ var (
 	reAmt       = `[[:digit:]]+`
 	reDecAmt    = `[[:digit:]]*\.[[:digit:]]+`
 	reSpc       = `[[:space:]]*`
-	reDnm       = regexp.MustCompile(fmt.Sprintf(`^%s$`, reDnmString))
-	reCoin      = regexp.MustCompile(fmt.Sprintf(`^(%s)%s(%s)$`, reAmt, reSpc, reDnmString))
-	reDecCoin   = regexp.MustCompile(fmt.Sprintf(`^(%s)%s(%s)$`, reDecAmt, reSpc, reDnmString))
+	reDnm       = returnReDnm
+	reCoin      = returnReCoin
+	reDecCoin   = returnDecCoin
 )
 
+func returnDecCoin() *regexp.Regexp {
+	return regexp.MustCompile(fmt.Sprintf(`^(%s)%s(%s)$`, reDecAmt, reSpc, CoinDenomRegex()))
+}
+func returnReCoin() *regexp.Regexp {
+	return regexp.MustCompile(fmt.Sprintf(`^(%s)%s(%s)$`, reAmt, reSpc, CoinDenomRegex()))
+}
+func returnReDnm() *regexp.Regexp {
+	return regexp.MustCompile(fmt.Sprintf(`^%s$`, CoinDenomRegex()))
+}
+
+// DefaultCoinDenomRegex returns the default regex string
+func DefaultCoinDenomRegex() string {
+	return reDnmString
+}
+
+// CoinDenomRegex returns the current regex string and can be overwritten for custom validation
+var CoinDenomRegex = DefaultCoinDenomRegex
+
 // ValidateDenom validates a denomination string returning an error if it is
 // invalid.
 func ValidateDenom(denom string) error {
-	if !reDnm.MatchString(denom) {
+	if !reDnm().MatchString(denom) {
 		return fmt.Errorf("invalid denom: %s", denom)
 	}
 	return nil
@@ -624,7 +642,7 @@ func mustValidateDenom(denom string) {
 func ParseCoin(coinStr string) (coin Coin, err error) {
 	coinStr = strings.TrimSpace(coinStr)
 
-	matches := reCoin.FindStringSubmatch(coinStr)
+	matches := reCoin().FindStringSubmatch(coinStr)
 	if matches == nil {
 		return Coin{}, fmt.Errorf("invalid coin expression: %s", coinStr)
 	}

types/coin_test.go

@@ -70,6 +70,31 @@ func TestCoinIsValid(t *testing.T) {
 	}
 }
 
+func TestCustomValidation(t *testing.T) {
+
+	newDnmRegex := `[\x{1F600}-\x{1F6FF}]`
+	CoinDenomRegex = func() string {
+		return newDnmRegex
+	}
+
+	cases := []struct {
+		coin       Coin
+		expectPass bool
+	}{
+		{Coin{"🙂", NewInt(1)}, true},
+		{Coin{"😃", NewInt(1)}, true},
+		{Coin{"😄", NewInt(1)}, true},
+		{Coin{"🌶", NewInt(1)}, false}, // outside the unicode range listed above
+		{Coin{"asdf", NewInt(1)}, false},
+		{Coin{"", NewInt(1)}, false},
+	}
+
+	for i, tc := range cases {
+		require.Equal(t, tc.expectPass, tc.coin.IsValid(), "unexpected result for IsValid, tc #%d", i)
+	}
+	CoinDenomRegex = DefaultCoinDenomRegex
+}
+
 func TestAddCoin(t *testing.T) {
 	cases := []struct {
 		inputOne    Coin

types/dec_coin.go

@@ -600,7 +600,7 @@ func (coins DecCoins) Sort() DecCoins {
 func ParseDecCoin(coinStr string) (coin DecCoin, err error) {
 	coinStr = strings.TrimSpace(coinStr)
 
-	matches := reDecCoin.FindStringSubmatch(coinStr)
+	matches := reDecCoin().FindStringSubmatch(coinStr)
 	if matches == nil {
 		return DecCoin{}, fmt.Errorf("invalid decimal coin expression: %s", coinStr)
 	}