From 7e8cb89602b51d5eab7966ed5df32e3002e67e8d Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Thu, 27 Jun 2024 17:37:03 -0700
Subject: [PATCH 01/17] feat: add TokenMapping query to proto file

---
 proto/eth/evm/v1/query.proto |  21 ++
 x/evm/query.pb.go            | 564 +++++++++++++++++++++++++++++------
 x/evm/query.pb.gw.go         | 101 +++++++
 3 files changed, 594 insertions(+), 92 deletions(-)

diff --git a/proto/eth/evm/v1/query.proto b/proto/eth/evm/v1/query.proto
index a42c61fac..e71083b29 100644
--- a/proto/eth/evm/v1/query.proto
+++ b/proto/eth/evm/v1/query.proto
@@ -75,6 +75,10 @@ service Query {
   rpc BaseFee(QueryBaseFeeRequest) returns (QueryBaseFeeResponse) {
     option (google.api.http).get = "/nibiru/evm/v1/base_fee";
   }
+
+  rpc TokenMapping(QueryTokenMappingRequest) returns (QueryTokenMappingResponse) {
+    option (google.api.http).get = "/nibiru/evm/v1/token_mapping/{token}";
+  }
 }
 
 // QueryEthAccountRequest is the request type for the Query/Account RPC method.
@@ -301,3 +305,20 @@ message QueryBaseFeeResponse {
   // base_fee is the EIP1559 base fee
   string base_fee = 1 [(gogoproto.customtype) = "cosmossdk.io/math.Int"];
 }
+
+message QueryTokenMappingRequest {
+  option (gogoproto.equal) = false;
+  option (gogoproto.goproto_getters) = false;
+
+  // token identifier can be either the hex contract address of the ERC20 or the
+	// Cosmos base denomination
+  string token = 1;
+}
+
+message QueryTokenMappingResponse {
+  option (gogoproto.equal) = false;
+  option (gogoproto.goproto_getters) = false;  
+
+  // fun_token is a mapping between the Cosmos native coin and the ERC20 contract address
+  FunToken fun_token = 1;
+}
\ No newline at end of file
diff --git a/x/evm/query.pb.go b/x/evm/query.pb.go
index b9e4e5804..dd77928fc 100644
--- a/x/evm/query.pb.go
+++ b/x/evm/query.pb.go
@@ -1303,6 +1303,83 @@ func (m *QueryBaseFeeResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryBaseFeeResponse proto.InternalMessageInfo
 
+type QueryTokenMappingRequest struct {
+	// token identifier can be either the hex contract address of the ERC20 or the
+	// Cosmos base denomination
+	Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
+}
+
+func (m *QueryTokenMappingRequest) Reset()         { *m = QueryTokenMappingRequest{} }
+func (m *QueryTokenMappingRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryTokenMappingRequest) ProtoMessage()    {}
+func (*QueryTokenMappingRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ffa36cdc5add14ed, []int{24}
+}
+func (m *QueryTokenMappingRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryTokenMappingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryTokenMappingRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryTokenMappingRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryTokenMappingRequest.Merge(m, src)
+}
+func (m *QueryTokenMappingRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryTokenMappingRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryTokenMappingRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryTokenMappingRequest proto.InternalMessageInfo
+
+type QueryTokenMappingResponse struct {
+	// fun_token is a mapping between the Cosmos native coin and the ERC20 contract address
+	FunToken *FunToken `protobuf:"bytes,1,opt,name=fun_token,json=funToken,proto3" json:"fun_token,omitempty"`
+}
+
+func (m *QueryTokenMappingResponse) Reset()         { *m = QueryTokenMappingResponse{} }
+func (m *QueryTokenMappingResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryTokenMappingResponse) ProtoMessage()    {}
+func (*QueryTokenMappingResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ffa36cdc5add14ed, []int{25}
+}
+func (m *QueryTokenMappingResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryTokenMappingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryTokenMappingResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryTokenMappingResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryTokenMappingResponse.Merge(m, src)
+}
+func (m *QueryTokenMappingResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryTokenMappingResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryTokenMappingResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryTokenMappingResponse proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterType((*QueryEthAccountRequest)(nil), "eth.evm.v1.QueryEthAccountRequest")
 	proto.RegisterType((*QueryEthAccountResponse)(nil), "eth.evm.v1.QueryEthAccountResponse")
@@ -1328,103 +1405,111 @@ func init() {
 	proto.RegisterType((*QueryTraceBlockResponse)(nil), "eth.evm.v1.QueryTraceBlockResponse")
 	proto.RegisterType((*QueryBaseFeeRequest)(nil), "eth.evm.v1.QueryBaseFeeRequest")
 	proto.RegisterType((*QueryBaseFeeResponse)(nil), "eth.evm.v1.QueryBaseFeeResponse")
+	proto.RegisterType((*QueryTokenMappingRequest)(nil), "eth.evm.v1.QueryTokenMappingRequest")
+	proto.RegisterType((*QueryTokenMappingResponse)(nil), "eth.evm.v1.QueryTokenMappingResponse")
 }
 
 func init() { proto.RegisterFile("eth/evm/v1/query.proto", fileDescriptor_ffa36cdc5add14ed) }
 
 var fileDescriptor_ffa36cdc5add14ed = []byte{
-	// 1454 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0x4f, 0x6f, 0x1b, 0x45,
-	0x14, 0xcf, 0xc6, 0x4e, 0xec, 0x3c, 0xa7, 0x6d, 0x98, 0xa6, 0x4d, 0xb2, 0x4d, 0xec, 0x74, 0x43,
-	0x93, 0xb4, 0xb4, 0xbb, 0x4d, 0x40, 0x20, 0x2a, 0x2a, 0xd4, 0x44, 0x69, 0x28, 0xfd, 0xa3, 0x62,
-	0x22, 0x0e, 0x48, 0xc8, 0x1a, 0xaf, 0x27, 0xeb, 0x55, 0xbc, 0x3b, 0xee, 0xce, 0x38, 0x38, 0x94,
-	0x5e, 0xe8, 0x05, 0x89, 0x03, 0x95, 0xf8, 0x02, 0x3d, 0xf1, 0x15, 0xf8, 0x04, 0x48, 0x3d, 0x56,
-	0xe2, 0x82, 0x38, 0x14, 0xd4, 0x72, 0xe0, 0xcc, 0x91, 0x13, 0x9a, 0x3f, 0x6b, 0xaf, 0xed, 0x75,
-	0x42, 0xf9, 0x73, 0xe3, 0xb4, 0x3b, 0x33, 0x6f, 0xde, 0xef, 0xf7, 0xe6, 0xcd, 0xbc, 0xf7, 0x83,
-	0xd3, 0x84, 0xd7, 0x1d, 0xb2, 0x1f, 0x38, 0xfb, 0x6b, 0xce, 0xbd, 0x16, 0x89, 0x0e, 0xec, 0x66,
-	0x44, 0x39, 0x45, 0x40, 0x78, 0xdd, 0x26, 0xfb, 0x81, 0xbd, 0xbf, 0x66, 0x5e, 0x70, 0x29, 0x0b,
-	0x28, 0x73, 0xaa, 0x98, 0x11, 0x65, 0xe4, 0xec, 0xaf, 0x55, 0x09, 0xc7, 0x6b, 0x4e, 0x13, 0x7b,
-	0x7e, 0x88, 0xb9, 0x4f, 0x43, 0xb5, 0xcf, 0x9c, 0x4e, 0xf8, 0x13, 0xdb, 0xd5, 0xec, 0xc9, 0xc4,
-	0x2c, 0x6f, 0xc7, 0xa6, 0x1e, 0xf5, 0xa8, 0xfc, 0x75, 0xc4, 0x9f, 0x9e, 0x9d, 0xf7, 0x28, 0xf5,
-	0x1a, 0xc4, 0xc1, 0x4d, 0xdf, 0xc1, 0x61, 0x48, 0xb9, 0xf4, 0xce, 0xf4, 0x6a, 0x49, 0xaf, 0xca,
-	0x51, 0xb5, 0xb5, 0xeb, 0x70, 0x3f, 0x20, 0x8c, 0xe3, 0xa0, 0xa9, 0x0c, 0xac, 0x77, 0xe0, 0xf4,
-	0x07, 0x82, 0xe1, 0x16, 0xaf, 0x5f, 0x73, 0x5d, 0xda, 0x0a, 0x79, 0x99, 0xdc, 0x6b, 0x11, 0xc6,
-	0xd1, 0x2c, 0xe4, 0x70, 0xad, 0x16, 0x11, 0xc6, 0x66, 0x8d, 0x45, 0x63, 0x75, 0xa2, 0x1c, 0x0f,
-	0xaf, 0xe4, 0xbf, 0x7c, 0x5c, 0x1a, 0xf9, 0xed, 0x71, 0x69, 0xc4, 0xda, 0x85, 0x99, 0x81, 0xdd,
-	0xac, 0x49, 0x43, 0x46, 0xc4, 0xf6, 0x2a, 0x6e, 0xe0, 0xd0, 0x25, 0xf1, 0x76, 0x3d, 0x44, 0x67,
-	0x60, 0xc2, 0xa5, 0x35, 0x52, 0xa9, 0x63, 0x56, 0x9f, 0x1d, 0x95, 0x6b, 0x79, 0x31, 0xf1, 0x1e,
-	0x66, 0x75, 0x34, 0x0d, 0x63, 0x21, 0x15, 0x9b, 0x32, 0x8b, 0xc6, 0x6a, 0xb6, 0xac, 0x06, 0xd6,
-	0xbb, 0x30, 0x27, 0x71, 0xee, 0xf8, 0x55, 0x3f, 0x6a, 0xfd, 0x0d, 0xa2, 0x07, 0x60, 0xa6, 0x39,
-	0xe8, 0x72, 0x4d, 0xf7, 0x80, 0x4c, 0xc8, 0x33, 0x01, 0x23, 0x18, 0x8d, 0x4a, 0x46, 0x9d, 0x31,
-	0x3a, 0x07, 0xc7, 0xb1, 0x72, 0x54, 0x09, 0x5b, 0x41, 0x95, 0x44, 0x9a, 0xf3, 0x31, 0x3d, 0x7b,
-	0x47, 0x4e, 0x5a, 0x37, 0x61, 0x5e, 0x42, 0x7f, 0x84, 0x1b, 0x7e, 0x0d, 0x73, 0x1a, 0xf5, 0xd1,
-	0x3f, 0x0b, 0x93, 0x2e, 0x0d, 0x59, 0xa5, 0x97, 0x41, 0x41, 0xcc, 0x5d, 0x1b, 0x88, 0xe3, 0x2b,
-	0x03, 0x16, 0x86, 0x78, 0xd3, 0xb1, 0xac, 0xc0, 0x89, 0x98, 0x55, 0xaf, 0xc7, 0x98, 0xec, 0xb5,
-	0x7f, 0x2f, 0xb4, 0xb7, 0xe1, 0xa4, 0x24, 0xb3, 0xa1, 0x32, 0xfb, 0x32, 0x09, 0xb9, 0x0c, 0xd3,
-	0xbd, 0x5b, 0x8f, 0xba, 0x36, 0xd6, 0x4d, 0x0d, 0xf6, 0x21, 0xa7, 0x11, 0xf6, 0x8e, 0x06, 0x43,
-	0x53, 0x90, 0xd9, 0x23, 0x07, 0xfa, 0x86, 0x89, 0xdf, 0x04, 0xfc, 0x45, 0x0d, 0xdf, 0x71, 0xa6,
-	0xe1, 0xa7, 0x61, 0x6c, 0x1f, 0x37, 0x5a, 0x31, 0xb8, 0x1a, 0x58, 0x6f, 0xc2, 0x94, 0xb4, 0xde,
-	0xa4, 0xb5, 0x97, 0x0a, 0x72, 0x05, 0x5e, 0x49, 0xec, 0xd3, 0x10, 0x08, 0xb2, 0xe2, 0xb6, 0xcb,
-	0x5d, 0x93, 0x65, 0xf9, 0x6f, 0x7d, 0x06, 0x48, 0x1a, 0xee, 0xb4, 0x6f, 0x51, 0x8f, 0xc5, 0x10,
-	0x08, 0xb2, 0xf2, 0x8d, 0x28, 0xff, 0xf2, 0x1f, 0x5d, 0x07, 0xe8, 0xd6, 0x10, 0x19, 0x5b, 0x61,
-	0x7d, 0xd9, 0x56, 0x05, 0xc7, 0x16, 0x05, 0xc7, 0x56, 0x55, 0x49, 0x17, 0x1c, 0xfb, 0x6e, 0xf7,
-	0xa8, 0xca, 0x89, 0x9d, 0x09, 0x92, 0x0f, 0x0d, 0x7d, 0xb0, 0x31, 0xb8, 0xe6, 0xb9, 0x04, 0xd9,
-	0x06, 0xf5, 0x44, 0x74, 0x99, 0xd5, 0xc2, 0xfa, 0x09, 0xbb, 0x5b, 0xe0, 0xec, 0x5b, 0xd4, 0x2b,
-	0xcb, 0x45, 0xb4, 0x9d, 0x42, 0x67, 0xe5, 0x48, 0x3a, 0x0a, 0x21, 0xc9, 0xc7, 0x9a, 0xd6, 0x27,
-	0x70, 0x17, 0x47, 0x38, 0x88, 0x4f, 0xc0, 0xda, 0xd6, 0xd4, 0xe2, 0x59, 0x4d, 0xed, 0x32, 0x8c,
-	0x37, 0xe5, 0x8c, 0x3c, 0x9a, 0xc2, 0x3a, 0x4a, 0x92, 0x53, 0xb6, 0x1b, 0xd9, 0x27, 0xcf, 0x4a,
-	0x23, 0x65, 0x6d, 0x67, 0x7d, 0x67, 0xc0, 0xf1, 0x2d, 0x5e, 0xdf, 0xc4, 0x8d, 0x46, 0xe2, 0x74,
-	0x71, 0xe4, 0xb1, 0x38, 0x0f, 0xe2, 0x1f, 0xcd, 0x40, 0xce, 0xc3, 0xac, 0xe2, 0xe2, 0xa6, 0x7e,
-	0x12, 0xe3, 0x1e, 0x66, 0x9b, 0xb8, 0x89, 0x3e, 0x81, 0xa9, 0x66, 0x44, 0x9b, 0x94, 0x91, 0xa8,
-	0xf3, 0xac, 0xc4, 0x93, 0x98, 0xdc, 0x58, 0xff, 0xe3, 0x59, 0xc9, 0xf6, 0x7c, 0x5e, 0x6f, 0x55,
-	0x6d, 0x97, 0x06, 0x8e, 0xae, 0xfd, 0xea, 0x73, 0x89, 0xd5, 0xf6, 0x1c, 0x7e, 0xd0, 0x24, 0xcc,
-	0xde, 0xec, 0xbe, 0xe7, 0xf2, 0x89, 0xd8, 0x57, 0xfc, 0x16, 0xe7, 0x20, 0xef, 0xd6, 0xb1, 0x1f,
-	0x56, 0xfc, 0xda, 0x6c, 0x76, 0xd1, 0x58, 0xcd, 0x94, 0x73, 0x72, 0x7c, 0xa3, 0x66, 0xad, 0xc0,
-	0xc9, 0x2d, 0xc6, 0xfd, 0x00, 0x73, 0xb2, 0x8d, 0xbb, 0x47, 0x30, 0x05, 0x19, 0x0f, 0x2b, 0xf2,
-	0xd9, 0xb2, 0xf8, 0xb5, 0x7e, 0xcf, 0xc4, 0x79, 0x8c, 0xb0, 0x4b, 0x76, 0xda, 0x71, 0x9c, 0xaf,
-	0x41, 0x26, 0x60, 0x9e, 0x3e, 0xa9, 0xb9, 0xe4, 0x49, 0xdd, 0x66, 0xde, 0x16, 0xaf, 0x93, 0x88,
-	0xb4, 0x82, 0x9d, 0x76, 0x59, 0x58, 0xa1, 0x2b, 0x30, 0xc9, 0xc5, 0xf6, 0x8a, 0x4b, 0xc3, 0x5d,
-	0xdf, 0x93, 0x31, 0x16, 0xd6, 0x67, 0x92, 0xbb, 0xa4, 0xfb, 0x4d, 0xb9, 0x5c, 0x2e, 0xf0, 0xee,
-	0x00, 0x5d, 0x85, 0xc9, 0x66, 0x44, 0x6a, 0xc4, 0x25, 0x8c, 0xd1, 0x88, 0xcd, 0x66, 0xe5, 0xc5,
-	0x39, 0x04, 0xb1, 0xc7, 0x5c, 0xd4, 0xc1, 0x6a, 0x83, 0xba, 0x7b, 0x71, 0xc5, 0x19, 0x93, 0xe7,
-	0x50, 0x90, 0x73, 0xaa, 0xde, 0xa0, 0x05, 0x00, 0x65, 0x22, 0x9f, 0xc5, 0xb8, 0x7c, 0x16, 0x13,
-	0x72, 0x46, 0xf6, 0x8e, 0xcd, 0x78, 0x59, 0x34, 0xb9, 0xd9, 0x9c, 0xa4, 0x6e, 0xda, 0xaa, 0x03,
-	0xda, 0x71, 0x07, 0xb4, 0x77, 0xe2, 0x0e, 0xb8, 0x91, 0x17, 0x57, 0xe4, 0xd1, 0xcf, 0x25, 0x43,
-	0x3b, 0x11, 0x2b, 0xa9, 0x99, 0xce, 0xff, 0x37, 0x99, 0x9e, 0xe8, 0xc9, 0x34, 0xb2, 0xe0, 0x98,
-	0xa2, 0x1f, 0xe0, 0x76, 0x45, 0x24, 0x17, 0x12, 0x27, 0x70, 0x1b, 0xb7, 0xb7, 0x31, 0x7b, 0x3f,
-	0x9b, 0x1f, 0x9d, 0xca, 0x94, 0xf3, 0xbc, 0x5d, 0xf1, 0xc3, 0x1a, 0x69, 0x5b, 0x17, 0x74, 0x1d,
-	0xeb, 0xe4, 0xbc, 0x5b, 0x64, 0x6a, 0x98, 0xe3, 0xf8, 0x72, 0x8b, 0x7f, 0xeb, 0xdb, 0x8c, 0xee,
-	0xf5, 0xd2, 0x78, 0x43, 0x78, 0x4d, 0xdc, 0x11, 0xde, 0x8e, 0x9f, 0xfa, 0x61, 0x77, 0x84, 0xb7,
-	0xd9, 0x3f, 0xba, 0x23, 0xff, 0x27, 0xf9, 0xe8, 0x24, 0x5b, 0x97, 0xb4, 0xaa, 0x4a, 0xe6, 0xe9,
-	0x90, 0xbc, 0x9e, 0xea, 0x74, 0x61, 0x46, 0xae, 0x93, 0xb8, 0xda, 0x5b, 0xb7, 0x3a, 0x1d, 0x56,
-	0x4f, 0x6b, 0x17, 0x6f, 0x40, 0x5e, 0x14, 0xe6, 0xca, 0x2e, 0xd1, 0x5d, 0x6e, 0x63, 0xee, 0xa7,
-	0x67, 0xa5, 0x53, 0x2a, 0x42, 0x56, 0xdb, 0xb3, 0x7d, 0xea, 0x04, 0x98, 0xd7, 0xed, 0x1b, 0x21,
-	0x17, 0xdd, 0x57, 0xee, 0x5e, 0xff, 0xbe, 0x00, 0x63, 0xd2, 0x1d, 0x7a, 0x68, 0x00, 0x74, 0xf5,
-	0x1e, 0xb2, 0x92, 0x79, 0x4f, 0x97, 0x92, 0xe6, 0xd2, 0xa1, 0x36, 0x8a, 0x97, 0x75, 0xf1, 0x8b,
-	0x1f, 0x7e, 0xfd, 0x66, 0x74, 0x19, 0xbd, 0xea, 0x84, 0x52, 0xa4, 0x75, 0x54, 0x31, 0xaf, 0x57,
-	0xb4, 0xec, 0x70, 0xee, 0xeb, 0x64, 0x3d, 0x40, 0x5f, 0x1b, 0x70, 0xac, 0x47, 0xcc, 0xa1, 0x73,
-	0x03, 0x20, 0x69, 0x6a, 0xd1, 0x5c, 0x3e, 0xca, 0x4c, 0xd3, 0x71, 0x24, 0x9d, 0xf3, 0x68, 0xa5,
-	0x8f, 0x8e, 0x1a, 0xa5, 0x30, 0x7a, 0x6c, 0xc0, 0x54, 0xbf, 0x2a, 0x43, 0xab, 0x03, 0x68, 0x43,
-	0x64, 0xa0, 0x79, 0xfe, 0x2f, 0x58, 0x6a, 0x6a, 0x6f, 0x49, 0x6a, 0x6b, 0xc8, 0xe9, 0xa3, 0xb6,
-	0x1f, 0x6f, 0xe8, 0xb2, 0x4b, 0x2a, 0xcb, 0x07, 0xe8, 0x53, 0xc8, 0x69, 0xbd, 0x85, 0x4a, 0x03,
-	0x70, 0xbd, 0x22, 0xce, 0x5c, 0x1c, 0x6e, 0xa0, 0x69, 0x9c, 0x97, 0x34, 0x96, 0xd0, 0xd9, 0x3e,
-	0x1a, 0x5a, 0xb0, 0xb1, 0xc4, 0xd9, 0x7c, 0x0e, 0x39, 0xad, 0xb4, 0x52, 0x80, 0x7b, 0x05, 0x5d,
-	0x0a, 0x70, 0x9f, 0x48, 0xb3, 0x6c, 0x09, 0xbc, 0x8a, 0x96, 0xfb, 0x80, 0x99, 0xb2, 0xeb, 0xe2,
-	0x3a, 0xf7, 0xf7, 0xc8, 0xc1, 0x03, 0xb4, 0x07, 0x59, 0xa1, 0xc0, 0xd0, 0xfc, 0x80, 0xe7, 0x84,
-	0xa0, 0x33, 0x17, 0x86, 0xac, 0x6a, 0xd0, 0x65, 0x09, 0xba, 0x88, 0x8a, 0x7d, 0xa0, 0x42, 0xbf,
-	0x25, 0x43, 0xad, 0xc3, 0xb8, 0x52, 0x20, 0xa8, 0x38, 0xe0, 0xb0, 0x47, 0xdc, 0x98, 0xa5, 0xa1,
-	0xeb, 0x1a, 0x72, 0x41, 0x42, 0xce, 0xa0, 0x53, 0x7d, 0x90, 0x4a, 0xd3, 0x20, 0x1f, 0x72, 0x5a,
-	0xd2, 0x20, 0x33, 0xe9, 0xaa, 0x57, 0xe7, 0x98, 0x67, 0x87, 0x97, 0xf3, 0x18, 0xa8, 0x24, 0x81,
-	0xe6, 0xd0, 0x4c, 0xca, 0xd3, 0x73, 0x85, 0x7f, 0x0a, 0x85, 0x84, 0x08, 0x39, 0x14, 0xae, 0x27,
-	0xaa, 0x14, 0xe5, 0x62, 0x2d, 0x49, 0xb0, 0x05, 0x74, 0xa6, 0x1f, 0x4c, 0xdb, 0x8a, 0xaa, 0x88,
-	0x02, 0xc8, 0xe9, 0x96, 0x96, 0x72, 0x61, 0x7a, 0x05, 0x4e, 0xca, 0x85, 0xe9, 0xeb, 0x86, 0x43,
-	0xe3, 0x53, 0x6d, 0x8c, 0xb7, 0xd1, 0x01, 0x40, 0xb7, 0xd8, 0xa6, 0x94, 0xb4, 0x81, 0x8e, 0x99,
-	0x52, 0xd2, 0x06, 0xab, 0xb5, 0x65, 0x49, 0xdc, 0x79, 0x64, 0xa6, 0xe2, 0xca, 0x92, 0x2f, 0x22,
-	0xd5, 0x15, 0x3a, 0xf5, 0x4d, 0x26, 0x4b, 0x7a, 0xea, 0x9b, 0xec, 0x29, 0xee, 0x43, 0x23, 0x8d,
-	0x2b, 0xfe, 0xc6, 0xd5, 0x27, 0xcf, 0x8b, 0xc6, 0xd3, 0xe7, 0x45, 0xe3, 0x97, 0xe7, 0x45, 0xe3,
-	0xd1, 0x8b, 0xe2, 0xc8, 0xd3, 0x17, 0xc5, 0x91, 0x1f, 0x5f, 0x14, 0x47, 0x3e, 0x5e, 0x4a, 0x74,
-	0x3d, 0x55, 0x12, 0x37, 0x45, 0xcf, 0x8a, 0x1d, 0xb5, 0x85, 0xab, 0xea, 0xb8, 0xec, 0xb0, 0xaf,
-	0xff, 0x19, 0x00, 0x00, 0xff, 0xff, 0x97, 0xcf, 0x5e, 0xd9, 0x07, 0x11, 0x00, 0x00,
+	// 1544 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0x4d, 0x6f, 0x1b, 0x55,
+	0x17, 0xce, 0xc4, 0x4e, 0xec, 0x1c, 0xa7, 0x6d, 0xde, 0xdb, 0xb4, 0x49, 0xa6, 0x89, 0x9d, 0x4e,
+	0xda, 0x24, 0xed, 0xdb, 0xce, 0x34, 0x01, 0x81, 0xa8, 0xa8, 0x50, 0x13, 0xa5, 0xa1, 0xf4, 0x43,
+	0xc5, 0x44, 0x08, 0x21, 0x21, 0xeb, 0xda, 0xbe, 0x19, 0x8f, 0xe2, 0x99, 0xeb, 0xce, 0xbd, 0x0e,
+	0x0e, 0x25, 0x1b, 0xba, 0x01, 0xb1, 0xa0, 0x12, 0x7f, 0xa0, 0x2b, 0xfe, 0x02, 0x7f, 0xa1, 0xcb,
+	0x22, 0x36, 0x88, 0x45, 0x41, 0x2d, 0x0b, 0xd6, 0x2c, 0x59, 0xa1, 0xfb, 0x31, 0xf1, 0x8c, 0x3d,
+	0x4e, 0x28, 0x1f, 0x3b, 0x56, 0x33, 0xf7, 0xde, 0x73, 0xce, 0xf3, 0x9c, 0xfb, 0x71, 0xce, 0x03,
+	0xa7, 0x09, 0x6f, 0x38, 0x64, 0xd7, 0x77, 0x76, 0x57, 0x9c, 0xfb, 0x6d, 0x12, 0xee, 0xd9, 0xad,
+	0x90, 0x72, 0x8a, 0x80, 0xf0, 0x86, 0x4d, 0x76, 0x7d, 0x7b, 0x77, 0xc5, 0xbc, 0x58, 0xa3, 0xcc,
+	0xa7, 0xcc, 0xa9, 0x62, 0x46, 0x94, 0x91, 0xb3, 0xbb, 0x52, 0x25, 0x1c, 0xaf, 0x38, 0x2d, 0xec,
+	0x7a, 0x01, 0xe6, 0x1e, 0x0d, 0x94, 0x9f, 0x39, 0x19, 0x8b, 0x27, 0xdc, 0xd5, 0xec, 0xc9, 0xd8,
+	0x2c, 0xef, 0x44, 0xa6, 0x2e, 0x75, 0xa9, 0xfc, 0x75, 0xc4, 0x9f, 0x9e, 0x9d, 0x75, 0x29, 0x75,
+	0x9b, 0xc4, 0xc1, 0x2d, 0xcf, 0xc1, 0x41, 0x40, 0xb9, 0x8c, 0xce, 0xf4, 0x6a, 0x49, 0xaf, 0xca,
+	0x51, 0xb5, 0xbd, 0xed, 0x70, 0xcf, 0x27, 0x8c, 0x63, 0xbf, 0xa5, 0x0c, 0xac, 0x37, 0xe1, 0xf4,
+	0xbb, 0x82, 0xe1, 0x06, 0x6f, 0x5c, 0xaf, 0xd5, 0x68, 0x3b, 0xe0, 0x65, 0x72, 0xbf, 0x4d, 0x18,
+	0x47, 0xd3, 0x90, 0xc3, 0xf5, 0x7a, 0x48, 0x18, 0x9b, 0x36, 0xe6, 0x8d, 0xe5, 0xb1, 0x72, 0x34,
+	0xbc, 0x9a, 0xff, 0xfc, 0x71, 0x69, 0xe8, 0xd7, 0xc7, 0xa5, 0x21, 0x6b, 0x1b, 0xa6, 0xfa, 0xbc,
+	0x59, 0x8b, 0x06, 0x8c, 0x08, 0xf7, 0x2a, 0x6e, 0xe2, 0xa0, 0x46, 0x22, 0x77, 0x3d, 0x44, 0x67,
+	0x60, 0xac, 0x46, 0xeb, 0xa4, 0xd2, 0xc0, 0xac, 0x31, 0x3d, 0x2c, 0xd7, 0xf2, 0x62, 0xe2, 0x6d,
+	0xcc, 0x1a, 0x68, 0x12, 0x46, 0x02, 0x2a, 0x9c, 0x32, 0xf3, 0xc6, 0x72, 0xb6, 0xac, 0x06, 0xd6,
+	0x5b, 0x30, 0x23, 0x71, 0xee, 0x7a, 0x55, 0x2f, 0x6c, 0xff, 0x05, 0xa2, 0x7b, 0x60, 0xa6, 0x05,
+	0xe8, 0x72, 0x4d, 0x8f, 0x80, 0x4c, 0xc8, 0x33, 0x01, 0x23, 0x18, 0x0d, 0x4b, 0x46, 0x07, 0x63,
+	0x74, 0x1e, 0x8e, 0x63, 0x15, 0xa8, 0x12, 0xb4, 0xfd, 0x2a, 0x09, 0x35, 0xe7, 0x63, 0x7a, 0xf6,
+	0xae, 0x9c, 0xb4, 0x6e, 0xc1, 0xac, 0x84, 0x7e, 0x1f, 0x37, 0xbd, 0x3a, 0xe6, 0x34, 0xec, 0xa1,
+	0x7f, 0x16, 0xc6, 0x6b, 0x34, 0x60, 0x95, 0x24, 0x83, 0x82, 0x98, 0xbb, 0xde, 0x97, 0xc7, 0x97,
+	0x06, 0xcc, 0x0d, 0x88, 0xa6, 0x73, 0x59, 0x82, 0x13, 0x11, 0xab, 0x64, 0xc4, 0x88, 0xec, 0xf5,
+	0x7f, 0x2e, 0xb5, 0x37, 0xe0, 0xa4, 0x24, 0xb3, 0xa6, 0x4e, 0xf6, 0x65, 0x0e, 0xe4, 0x0a, 0x4c,
+	0x26, 0x5d, 0x8f, 0xba, 0x36, 0xd6, 0x2d, 0x0d, 0xf6, 0x1e, 0xa7, 0x21, 0x76, 0x8f, 0x06, 0x43,
+	0x13, 0x90, 0xd9, 0x21, 0x7b, 0xfa, 0x86, 0x89, 0xdf, 0x18, 0xfc, 0x25, 0x0d, 0x7f, 0x10, 0x4c,
+	0xc3, 0x4f, 0xc2, 0xc8, 0x2e, 0x6e, 0xb6, 0x23, 0x70, 0x35, 0xb0, 0x5e, 0x83, 0x09, 0x69, 0xbd,
+	0x4e, 0xeb, 0x2f, 0x95, 0xe4, 0x12, 0xfc, 0x2f, 0xe6, 0xa7, 0x21, 0x10, 0x64, 0xc5, 0x6d, 0x97,
+	0x5e, 0xe3, 0x65, 0xf9, 0x6f, 0x7d, 0x02, 0x48, 0x1a, 0x6e, 0x75, 0x6e, 0x53, 0x97, 0x45, 0x10,
+	0x08, 0xb2, 0xf2, 0x8d, 0xa8, 0xf8, 0xf2, 0x1f, 0xdd, 0x00, 0xe8, 0xd6, 0x10, 0x99, 0x5b, 0x61,
+	0x75, 0xd1, 0x56, 0x05, 0xc7, 0x16, 0x05, 0xc7, 0x56, 0x55, 0x49, 0x17, 0x1c, 0xfb, 0x5e, 0x77,
+	0xab, 0xca, 0x31, 0xcf, 0x18, 0xc9, 0x87, 0x86, 0xde, 0xd8, 0x08, 0x5c, 0xf3, 0x5c, 0x80, 0x6c,
+	0x93, 0xba, 0x22, 0xbb, 0xcc, 0x72, 0x61, 0xf5, 0x84, 0xdd, 0x2d, 0x70, 0xf6, 0x6d, 0xea, 0x96,
+	0xe5, 0x22, 0xda, 0x4c, 0xa1, 0xb3, 0x74, 0x24, 0x1d, 0x85, 0x10, 0xe7, 0x63, 0x4d, 0xea, 0x1d,
+	0xb8, 0x87, 0x43, 0xec, 0x47, 0x3b, 0x60, 0x6d, 0x6a, 0x6a, 0xd1, 0xac, 0xa6, 0x76, 0x05, 0x46,
+	0x5b, 0x72, 0x46, 0x6e, 0x4d, 0x61, 0x15, 0xc5, 0xc9, 0x29, 0xdb, 0xb5, 0xec, 0x93, 0x67, 0xa5,
+	0xa1, 0xb2, 0xb6, 0xb3, 0xbe, 0x35, 0xe0, 0xf8, 0x06, 0x6f, 0xac, 0xe3, 0x66, 0x33, 0xb6, 0xbb,
+	0x38, 0x74, 0x59, 0x74, 0x0e, 0xe2, 0x1f, 0x4d, 0x41, 0xce, 0xc5, 0xac, 0x52, 0xc3, 0x2d, 0xfd,
+	0x24, 0x46, 0x5d, 0xcc, 0xd6, 0x71, 0x0b, 0x7d, 0x04, 0x13, 0xad, 0x90, 0xb6, 0x28, 0x23, 0xe1,
+	0xc1, 0xb3, 0x12, 0x4f, 0x62, 0x7c, 0x6d, 0xf5, 0xf7, 0x67, 0x25, 0xdb, 0xf5, 0x78, 0xa3, 0x5d,
+	0xb5, 0x6b, 0xd4, 0x77, 0x74, 0xed, 0x57, 0x9f, 0xcb, 0xac, 0xbe, 0xe3, 0xf0, 0xbd, 0x16, 0x61,
+	0xf6, 0x7a, 0xf7, 0x3d, 0x97, 0x4f, 0x44, 0xb1, 0xa2, 0xb7, 0x38, 0x03, 0xf9, 0x5a, 0x03, 0x7b,
+	0x41, 0xc5, 0xab, 0x4f, 0x67, 0xe7, 0x8d, 0xe5, 0x4c, 0x39, 0x27, 0xc7, 0x37, 0xeb, 0xd6, 0x12,
+	0x9c, 0xdc, 0x60, 0xdc, 0xf3, 0x31, 0x27, 0x9b, 0xb8, 0xbb, 0x05, 0x13, 0x90, 0x71, 0xb1, 0x22,
+	0x9f, 0x2d, 0x8b, 0x5f, 0xeb, 0xb7, 0x4c, 0x74, 0x8e, 0x21, 0xae, 0x91, 0xad, 0x4e, 0x94, 0xe7,
+	0xff, 0x21, 0xe3, 0x33, 0x57, 0xef, 0xd4, 0x4c, 0x7c, 0xa7, 0xee, 0x30, 0x77, 0x83, 0x37, 0x48,
+	0x48, 0xda, 0xfe, 0x56, 0xa7, 0x2c, 0xac, 0xd0, 0x55, 0x18, 0xe7, 0xc2, 0xbd, 0x52, 0xa3, 0xc1,
+	0xb6, 0xe7, 0xca, 0x1c, 0x0b, 0xab, 0x53, 0x71, 0x2f, 0x19, 0x7e, 0x5d, 0x2e, 0x97, 0x0b, 0xbc,
+	0x3b, 0x40, 0xd7, 0x60, 0xbc, 0x15, 0x92, 0x3a, 0xa9, 0x11, 0xc6, 0x68, 0xc8, 0xa6, 0xb3, 0xf2,
+	0xe2, 0x1c, 0x82, 0x98, 0x30, 0x17, 0x75, 0xb0, 0xda, 0xa4, 0xb5, 0x9d, 0xa8, 0xe2, 0x8c, 0xc8,
+	0x7d, 0x28, 0xc8, 0x39, 0x55, 0x6f, 0xd0, 0x1c, 0x80, 0x32, 0x91, 0xcf, 0x62, 0x54, 0x3e, 0x8b,
+	0x31, 0x39, 0x23, 0x7b, 0xc7, 0x7a, 0xb4, 0x2c, 0x9a, 0xdc, 0x74, 0x4e, 0x52, 0x37, 0x6d, 0xd5,
+	0x01, 0xed, 0xa8, 0x03, 0xda, 0x5b, 0x51, 0x07, 0x5c, 0xcb, 0x8b, 0x2b, 0xf2, 0xe8, 0xa7, 0x92,
+	0xa1, 0x83, 0x88, 0x95, 0xd4, 0x93, 0xce, 0xff, 0x3b, 0x27, 0x3d, 0x96, 0x38, 0x69, 0x64, 0xc1,
+	0x31, 0x45, 0xdf, 0xc7, 0x9d, 0x8a, 0x38, 0x5c, 0x88, 0xed, 0xc0, 0x1d, 0xdc, 0xd9, 0xc4, 0xec,
+	0x9d, 0x6c, 0x7e, 0x78, 0x22, 0x53, 0xce, 0xf3, 0x4e, 0xc5, 0x0b, 0xea, 0xa4, 0x63, 0x5d, 0xd4,
+	0x75, 0xec, 0xe0, 0xcc, 0xbb, 0x45, 0xa6, 0x8e, 0x39, 0x8e, 0x2e, 0xb7, 0xf8, 0xb7, 0xbe, 0xc9,
+	0xe8, 0x5e, 0x2f, 0x8d, 0xd7, 0x44, 0xd4, 0xd8, 0x1d, 0xe1, 0x9d, 0xe8, 0xa9, 0x1f, 0x76, 0x47,
+	0x78, 0x87, 0xfd, 0xad, 0x3b, 0xf2, 0xdf, 0x21, 0x1f, 0x7d, 0xc8, 0xd6, 0x65, 0xad, 0xaa, 0xe2,
+	0xe7, 0x74, 0xc8, 0xb9, 0x9e, 0x3a, 0xe8, 0xc2, 0x8c, 0xdc, 0x20, 0x51, 0xb5, 0xb7, 0x6e, 0x1f,
+	0x74, 0x58, 0x3d, 0xad, 0x43, 0xbc, 0x0a, 0x79, 0x51, 0x98, 0x2b, 0xdb, 0x44, 0x77, 0xb9, 0xb5,
+	0x99, 0x1f, 0x9f, 0x95, 0x4e, 0xa9, 0x0c, 0x59, 0x7d, 0xc7, 0xf6, 0xa8, 0xe3, 0x63, 0xde, 0xb0,
+	0x6f, 0x06, 0x5c, 0x74, 0x5f, 0xe9, 0x6d, 0x5d, 0x85, 0x69, 0xc5, 0x89, 0xee, 0x90, 0xe0, 0x0e,
+	0x6e, 0xb5, 0xbc, 0xc0, 0x8d, 0x6e, 0xcf, 0x24, 0x8c, 0x70, 0x31, 0x1d, 0x35, 0x4d, 0x39, 0x88,
+	0x75, 0x98, 0x0f, 0xb4, 0x7a, 0x4b, 0xfa, 0x6a, 0x3a, 0x2b, 0x30, 0xb6, 0xdd, 0x0e, 0x2a, 0xdd,
+	0x00, 0x85, 0xd5, 0xc9, 0xf8, 0x55, 0xba, 0xd1, 0x0e, 0xa4, 0x5f, 0x39, 0xbf, 0xad, 0xff, 0xba,
+	0x91, 0x57, 0xbf, 0x1b, 0x87, 0x11, 0x19, 0x1a, 0x3d, 0x34, 0x00, 0xba, 0x2a, 0x14, 0x59, 0xf1,
+	0x10, 0xe9, 0x02, 0xd7, 0x5c, 0x38, 0xd4, 0x46, 0xd1, 0xb3, 0x2e, 0x7d, 0xf6, 0xfd, 0x2f, 0x5f,
+	0x0f, 0x2f, 0xa2, 0x73, 0x4e, 0x20, 0xa5, 0xe3, 0x81, 0x56, 0xe7, 0x8d, 0x8a, 0x16, 0x43, 0xce,
+	0x03, 0x7d, 0x85, 0xf6, 0xd1, 0x57, 0x06, 0x1c, 0x4b, 0x48, 0x4c, 0x74, 0xbe, 0x0f, 0x24, 0x4d,
+	0xc3, 0x9a, 0x8b, 0x47, 0x99, 0x69, 0x3a, 0x8e, 0xa4, 0x73, 0x01, 0x2d, 0xf5, 0xd0, 0x51, 0xa3,
+	0x14, 0x46, 0x8f, 0x0d, 0x98, 0xe8, 0xd5, 0x8a, 0x68, 0xb9, 0x0f, 0x6d, 0x80, 0x38, 0x35, 0x2f,
+	0xfc, 0x09, 0x4b, 0x4d, 0xed, 0x75, 0x49, 0x6d, 0x05, 0x39, 0x3d, 0xd4, 0x76, 0x23, 0x87, 0x2e,
+	0xbb, 0xb8, 0xde, 0xdd, 0x47, 0x1f, 0x43, 0x4e, 0xab, 0x40, 0x54, 0xea, 0x83, 0x4b, 0x4a, 0x4b,
+	0x73, 0x7e, 0xb0, 0x81, 0xa6, 0x71, 0x41, 0xd2, 0x58, 0x40, 0x67, 0x7b, 0x68, 0x68, 0x19, 0xc9,
+	0x62, 0x7b, 0xf3, 0x29, 0xe4, 0xb4, 0xfe, 0x4b, 0x01, 0x4e, 0xca, 0xcc, 0x14, 0xe0, 0x1e, 0xe9,
+	0x68, 0xd9, 0x12, 0x78, 0x19, 0x2d, 0xf6, 0x00, 0x33, 0x65, 0xd7, 0xc5, 0x75, 0x1e, 0xec, 0x90,
+	0xbd, 0x7d, 0xb4, 0x03, 0x59, 0xa1, 0x0b, 0xd1, 0x6c, 0x5f, 0xe4, 0x98, 0xcc, 0x34, 0xe7, 0x06,
+	0xac, 0x6a, 0xd0, 0x45, 0x09, 0x3a, 0x8f, 0x8a, 0x3d, 0xa0, 0x42, 0x55, 0xc6, 0x53, 0x6d, 0xc0,
+	0xa8, 0xd2, 0x45, 0xa8, 0xd8, 0x17, 0x30, 0x21, 0xb9, 0xcc, 0xd2, 0xc0, 0x75, 0x0d, 0x39, 0x27,
+	0x21, 0xa7, 0xd0, 0xa9, 0x1e, 0x48, 0xa5, 0xb4, 0x90, 0x07, 0x39, 0x2d, 0xb4, 0x90, 0x19, 0x0f,
+	0x95, 0x54, 0x5f, 0xe6, 0xd9, 0xc1, 0x4d, 0x26, 0x02, 0x2a, 0x49, 0xa0, 0x19, 0x34, 0x95, 0xf2,
+	0xf4, 0x6a, 0x22, 0x3e, 0x85, 0x42, 0x4c, 0x1a, 0x1d, 0x0a, 0x97, 0xc8, 0x2a, 0x45, 0x4f, 0x59,
+	0x0b, 0x12, 0x6c, 0x0e, 0x9d, 0xe9, 0x05, 0xd3, 0xb6, 0xa2, 0x56, 0x23, 0x1f, 0x72, 0xba, 0xd1,
+	0xa6, 0x5c, 0x98, 0xa4, 0xec, 0x4a, 0xb9, 0x30, 0x3d, 0x3d, 0x7a, 0x60, 0x7e, 0xaa, 0xb9, 0xf2,
+	0x0e, 0xda, 0x03, 0xe8, 0xb6, 0x80, 0x94, 0x92, 0xd6, 0xd7, 0xc7, 0x53, 0x4a, 0x5a, 0x7f, 0x0f,
+	0xb1, 0x2c, 0x89, 0x3b, 0x8b, 0xcc, 0x54, 0x5c, 0xd9, 0x88, 0x44, 0xa6, 0xba, 0x6f, 0xa4, 0xbe,
+	0xc9, 0x78, 0xa3, 0x49, 0x7d, 0x93, 0x89, 0x96, 0x33, 0x30, 0xd3, 0xa8, 0x0f, 0xa1, 0x2f, 0x0c,
+	0x18, 0x8f, 0x77, 0x07, 0x74, 0xae, 0x3f, 0x91, 0xfe, 0xc6, 0x63, 0x9e, 0x3f, 0xc2, 0xea, 0x88,
+	0x1a, 0x2e, 0x7b, 0x4e, 0xc5, 0x57, 0xd6, 0xce, 0x03, 0x39, 0xdc, 0x5f, 0xbb, 0xf6, 0xe4, 0x79,
+	0xd1, 0x78, 0xfa, 0xbc, 0x68, 0xfc, 0xfc, 0xbc, 0x68, 0x3c, 0x7a, 0x51, 0x1c, 0x7a, 0xfa, 0xa2,
+	0x38, 0xf4, 0xc3, 0x8b, 0xe2, 0xd0, 0x87, 0x0b, 0x31, 0x5d, 0xa0, 0xca, 0xf3, 0xba, 0xe8, 0xea,
+	0x51, 0xd4, 0x8e, 0x88, 0x5b, 0x1d, 0x95, 0x1a, 0xe4, 0x95, 0x3f, 0x02, 0x00, 0x00, 0xff, 0xff,
+	0xf0, 0xb1, 0xd3, 0x70, 0x29, 0x12, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1466,6 +1551,7 @@ type QueryClient interface {
 	// BaseFee queries the base fee of the parent block of the current block,
 	// Similar to feemarket module's method
 	BaseFee(ctx context.Context, in *QueryBaseFeeRequest, opts ...grpc.CallOption) (*QueryBaseFeeResponse, error)
+	TokenMapping(ctx context.Context, in *QueryTokenMappingRequest, opts ...grpc.CallOption) (*QueryTokenMappingResponse, error)
 }
 
 type queryClient struct {
@@ -1584,6 +1670,15 @@ func (c *queryClient) BaseFee(ctx context.Context, in *QueryBaseFeeRequest, opts
 	return out, nil
 }
 
+func (c *queryClient) TokenMapping(ctx context.Context, in *QueryTokenMappingRequest, opts ...grpc.CallOption) (*QueryTokenMappingResponse, error) {
+	out := new(QueryTokenMappingResponse)
+	err := c.cc.Invoke(ctx, "/eth.evm.v1.Query/TokenMapping", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // QueryServer is the server API for Query service.
 type QueryServer interface {
 	// EthAccount queries an Ethereum account.
@@ -1613,6 +1708,7 @@ type QueryServer interface {
 	// BaseFee queries the base fee of the parent block of the current block,
 	// Similar to feemarket module's method
 	BaseFee(context.Context, *QueryBaseFeeRequest) (*QueryBaseFeeResponse, error)
+	TokenMapping(context.Context, *QueryTokenMappingRequest) (*QueryTokenMappingResponse, error)
 }
 
 // UnimplementedQueryServer can be embedded to have forward compatible implementations.
@@ -1655,6 +1751,9 @@ func (*UnimplementedQueryServer) TraceBlock(ctx context.Context, req *QueryTrace
 func (*UnimplementedQueryServer) BaseFee(ctx context.Context, req *QueryBaseFeeRequest) (*QueryBaseFeeResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method BaseFee not implemented")
 }
+func (*UnimplementedQueryServer) TokenMapping(ctx context.Context, req *QueryTokenMappingRequest) (*QueryTokenMappingResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method TokenMapping not implemented")
+}
 
 func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
 	s.RegisterService(&_Query_serviceDesc, srv)
@@ -1876,6 +1975,24 @@ func _Query_BaseFee_Handler(srv interface{}, ctx context.Context, dec func(inter
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_TokenMapping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryTokenMappingRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).TokenMapping(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/eth.evm.v1.Query/TokenMapping",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).TokenMapping(ctx, req.(*QueryTokenMappingRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Query_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "eth.evm.v1.Query",
 	HandlerType: (*QueryServer)(nil),
@@ -1928,6 +2045,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "BaseFee",
 			Handler:    _Query_BaseFee_Handler,
 		},
+		{
+			MethodName: "TokenMapping",
+			Handler:    _Query_TokenMapping_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "eth/evm/v1/query.proto",
@@ -2856,6 +2977,71 @@ func (m *QueryBaseFeeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *QueryTokenMappingRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryTokenMappingRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryTokenMappingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Token) > 0 {
+		i -= len(m.Token)
+		copy(dAtA[i:], m.Token)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Token)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryTokenMappingResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryTokenMappingResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryTokenMappingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.FunToken != nil {
+		{
+			size, err := m.FunToken.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
 	offset -= sovQuery(v)
 	base := offset
@@ -3265,6 +3451,32 @@ func (m *QueryBaseFeeResponse) Size() (n int) {
 	return n
 }
 
+func (m *QueryTokenMappingRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Token)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryTokenMappingResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.FunToken != nil {
+		l = m.FunToken.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
 func sovQuery(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -5904,6 +6116,174 @@ func (m *QueryBaseFeeResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *QueryTokenMappingRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryTokenMappingRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryTokenMappingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Token = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryTokenMappingResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryTokenMappingResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryTokenMappingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FunToken", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.FunToken == nil {
+				m.FunToken = &FunToken{}
+			}
+			if err := m.FunToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipQuery(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/x/evm/query.pb.gw.go b/x/evm/query.pb.gw.go
index fd0ecc413..f9b679e79 100644
--- a/x/evm/query.pb.gw.go
+++ b/x/evm/query.pb.gw.go
@@ -559,6 +559,60 @@ func local_request_Query_BaseFee_0(ctx context.Context, marshaler runtime.Marsha
 
 }
 
+func request_Query_TokenMapping_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryTokenMappingRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["token"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "token")
+	}
+
+	protoReq.Token, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "token", err)
+	}
+
+	msg, err := client.TokenMapping(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_TokenMapping_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryTokenMappingRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["token"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "token")
+	}
+
+	protoReq.Token, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "token", err)
+	}
+
+	msg, err := server.TokenMapping(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 // RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
 // UnaryRPC     :call QueryServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -841,6 +895,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 
 	})
 
+	mux.Handle("GET", pattern_Query_TokenMapping_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_TokenMapping_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_TokenMapping_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -1122,6 +1199,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_TokenMapping_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_TokenMapping_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_TokenMapping_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -1149,6 +1246,8 @@ var (
 	pattern_Query_TraceBlock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"nibiru", "evm", "v1", "trace_block"}, "", runtime.AssumeColonVerbOpt(false)))
 
 	pattern_Query_BaseFee_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"nibiru", "evm", "v1", "base_fee"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Query_TokenMapping_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"nibiru", "evm", "v1", "token_mapping", "token"}, "", runtime.AssumeColonVerbOpt(false)))
 )
 
 var (
@@ -1175,4 +1274,6 @@ var (
 	forward_Query_TraceBlock_0 = runtime.ForwardResponseMessage
 
 	forward_Query_BaseFee_0 = runtime.ForwardResponseMessage
+
+	forward_Query_TokenMapping_0 = runtime.ForwardResponseMessage
 )

From aad78c5756c4b4913de1a6420a609d31e9417233 Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Thu, 27 Jun 2024 17:37:14 -0700
Subject: [PATCH 02/17] refactor: use evm package import

---
 x/evm/keeper/funtoken_state.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/x/evm/keeper/funtoken_state.go b/x/evm/keeper/funtoken_state.go
index c713c1fc3..10bcaca13 100644
--- a/x/evm/keeper/funtoken_state.go
+++ b/x/evm/keeper/funtoken_state.go
@@ -10,12 +10,11 @@ import (
 
 	"github.com/NibiruChain/nibiru/eth"
 	"github.com/NibiruChain/nibiru/x/evm"
-	funtoken "github.com/NibiruChain/nibiru/x/evm"
 )
 
 type (
 	funtokenPrimaryKeyType = []byte
-	funtokenValueType      = funtoken.FunToken
+	funtokenValueType      = evm.FunToken
 )
 
 // FunTokenState isolates the key-value stores (collections) for fungible token

From aefbfa604fece8696272f137fdd50c4ee3a0b3ef Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Thu, 27 Jun 2024 17:37:21 -0700
Subject: [PATCH 03/17] feat: implement TokenMapping grpc query

---
 x/evm/keeper/grpc_query.go | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/x/evm/keeper/grpc_query.go b/x/evm/keeper/grpc_query.go
index 2add8c1fe..a0dad4a3e 100644
--- a/x/evm/keeper/grpc_query.go
+++ b/x/evm/keeper/grpc_query.go
@@ -740,3 +740,18 @@ func (k *Keeper) TraceEthTxMsg(
 
 	return &result, txConfig.LogIndex + uint(len(res.Logs)), nil
 }
+
+func (k Keeper) TokenMapping(
+	goCtx context.Context, req *evm.QueryTokenMappingRequest,
+) (*evm.QueryTokenMappingResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	funToken, err := k.FunTokens.Get(ctx, []byte(req.Token))
+	if err != nil {
+		return nil, grpcstatus.Errorf(grpccodes.NotFound, "token not found for %s", req.Token)
+	}
+
+	return &evm.QueryTokenMappingResponse{
+		FunToken: &funToken,
+	}, nil
+}

From cfb5f7bf4605ed9628a8fb39bf938c584c43ed6c Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 07:43:43 -0700
Subject: [PATCH 04/17] test: add TokenMapping mock function

---
 eth/rpc/backend/mocks/evm_query_client.go | 30 +++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/eth/rpc/backend/mocks/evm_query_client.go b/eth/rpc/backend/mocks/evm_query_client.go
index e018a93a2..87834eff5 100644
--- a/eth/rpc/backend/mocks/evm_query_client.go
+++ b/eth/rpc/backend/mocks/evm_query_client.go
@@ -377,6 +377,36 @@ func (_m *EVMQueryClient) ValidatorAccount(ctx context.Context, in *evm.QueryVal
 	return r0, r1
 }
 
+// ValidatorAccount provides a mock function with given fields: ctx, in, opts
+func (_m *EVMQueryClient) TokenMapping(ctx context.Context, in *evm.QueryTokenMappingRequest, opts ...grpc.CallOption) (*evm.QueryTokenMappingResponse, error) {
+	_va := make([]interface{}, len(opts))
+	for _i := range opts {
+		_va[_i] = opts[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, in)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	var r0 *evm.QueryTokenMappingResponse
+	if rf, ok := ret.Get(0).(func(context.Context, *evm.QueryTokenMappingRequest, ...grpc.CallOption) *evm.QueryTokenMappingResponse); ok {
+		r0 = rf(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*evm.QueryTokenMappingResponse)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *evm.QueryTokenMappingRequest, ...grpc.CallOption) error); ok {
+		r1 = rf(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
 type mockConstructorTestingTNewEVMQueryClient interface {
 	mock.TestingT
 	Cleanup(func())

From b5c2c862495923053c6ed43ae0c4528b57624c12 Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 09:07:21 -0700
Subject: [PATCH 05/17] test: query token mapping grps

---
 x/evm/keeper/grpc_query_test.go | 62 +++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/x/evm/keeper/grpc_query_test.go b/x/evm/keeper/grpc_query_test.go
index 49c13a34a..79fbb4ed5 100644
--- a/x/evm/keeper/grpc_query_test.go
+++ b/x/evm/keeper/grpc_query_test.go
@@ -894,3 +894,65 @@ func (s *KeeperSuite) TestTestTraceBlock() {
 		})
 	}
 }
+
+func (s *KeeperSuite) TestQueryTokenMapping() {
+	type In = *evm.QueryTokenMappingRequest
+	type Out = *evm.QueryTokenMappingResponse
+	testCases := []TestCase[In, Out]{
+		{
+			name: "sad: no token mapping",
+			scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) {
+				req = &evm.QueryTokenMappingRequest{
+					Token: "unibi",
+				}
+				wantResp = &evm.QueryTokenMappingResponse{
+					FunToken: nil,
+				}
+				return req, wantResp
+			},
+			wantErr: "token not found for unibi",
+		},
+		{
+			name: "happy: token mapping exists from cosmos coin -> ERC20 token",
+			setup: func(deps *evmtest.TestDeps) {
+				deps.K.FunTokens.Insert(deps.Ctx, []byte("unibi"), evm.FunToken{
+					Erc20Addr:      "0xAEf9437FF23D48D73271a41a8A094DEc9ac71477",
+					BankDenom:      "unibi",
+					IsMadeFromCoin: true,
+				})
+			},
+			scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) {
+				req = &evm.QueryTokenMappingRequest{
+					Token: "unibi",
+				}
+				wantResp = &evm.QueryTokenMappingResponse{
+					FunToken: &evm.FunToken{
+						Erc20Addr:      "0xAEf9437FF23D48D73271a41a8A094DEc9ac71477",
+						BankDenom:      "unibi",
+						IsMadeFromCoin: true,
+					},
+				}
+				return req, wantResp
+			},
+			wantErr: "",
+		},
+	}
+
+	for _, tc := range testCases {
+		s.Run(tc.name, func() {
+			deps := evmtest.NewTestDeps()
+			if tc.setup != nil {
+				tc.setup(&deps)
+			}
+			req, wantResp := tc.scenario(&deps)
+			goCtx := sdk.WrapSDKContext(deps.Ctx)
+			gotResp, err := deps.K.TokenMapping(goCtx, req)
+			if tc.wantErr != "" {
+				s.Require().ErrorContains(err, tc.wantErr)
+				return
+			}
+			s.Assert().NoError(err)
+			s.EqualValues(wantResp, gotResp)
+		})
+	}
+}

From 0ca249ba6ae2613ff5d4edca1ac35010590e0712 Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 09:36:43 -0700
Subject: [PATCH 06/17] fix: HexAddr marshalling issue

---
 eth/hex.go                          |  2 +-
 x/evm/keeper/funtoken_state_test.go | 82 +++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+), 1 deletion(-)
 create mode 100644 x/evm/keeper/funtoken_state_test.go

diff --git a/eth/hex.go b/eth/hex.go
index 3e6cf0cde..e70a26efb 100644
--- a/eth/hex.go
+++ b/eth/hex.go
@@ -88,7 +88,7 @@ func (h HexAddr) MarshalJSON() ([]byte, error) {
 // Implements the gogo proto custom type interface.
 // Ref: https://github.com/cosmos/gogoproto/blob/v1.5.0/custom_types.md
 func (h *HexAddr) MarshalTo(data []byte) (n int, err error) {
-	bz := []byte{}
+	bz := []byte(*h)
 	copy(data, bz)
 	hexAddr, err := NewHexAddrFromStr(string(bz))
 	*h = hexAddr
diff --git a/x/evm/keeper/funtoken_state_test.go b/x/evm/keeper/funtoken_state_test.go
new file mode 100644
index 000000000..ee9e4c928
--- /dev/null
+++ b/x/evm/keeper/funtoken_state_test.go
@@ -0,0 +1,82 @@
+package keeper_test
+
+import (
+	gethcommon "github.com/ethereum/go-ethereum/common"
+
+	"github.com/NibiruChain/nibiru/eth"
+	"github.com/NibiruChain/nibiru/x/evm"
+	"github.com/NibiruChain/nibiru/x/evm/evmtest"
+)
+
+func (s *KeeperSuite) TestInsertAndGet() {
+	deps := evmtest.NewTestDeps()
+
+	erc20Addr := gethcommon.HexToAddress("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477")
+	err := deps.K.FunTokens.SafeInsert(
+		deps.Ctx,
+		erc20Addr,
+		"unibi",
+		true,
+	)
+	s.Require().NoError(err)
+
+	// test Get
+	funToken, err := deps.K.FunTokens.Get(deps.Ctx, evm.NewFunTokenID(erc20Addr, "unibi"))
+	s.Require().NoError(err)
+	s.Require().Equal(eth.HexAddr("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477"), funToken.Erc20Addr)
+	s.Require().Equal("unibi", funToken.BankDenom)
+	s.Require().True(funToken.IsMadeFromCoin)
+
+	// iter := deps.K.FunTokens.Indexes.BankDenom.ExactMatch(deps.Ctx, "unibi")
+	// deps.K.FunTokens.Collect(ctx)
+}
+
+func (s *KeeperSuite) TestCollect() {
+	deps := evmtest.NewTestDeps()
+
+	erc20Addr := gethcommon.HexToAddress("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477")
+	err := deps.K.FunTokens.SafeInsert(
+		deps.Ctx,
+		erc20Addr,
+		"unibi",
+		true,
+	)
+	s.Require().NoError(err)
+
+	// test Collect by bank denom
+	iter := deps.K.FunTokens.Indexes.BankDenom.ExactMatch(deps.Ctx, "unibi")
+	funTokens := deps.K.FunTokens.Collect(deps.Ctx, iter)
+	s.Require().Len(funTokens, 1)
+	s.Require().Equal(eth.HexAddr("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477"), funTokens[0].Erc20Addr)
+	s.Require().Equal("unibi", funTokens[0].BankDenom)
+	s.Require().True(funTokens[0].IsMadeFromCoin)
+
+	// test Collect by erc20 addr
+	iter2 := deps.K.FunTokens.Indexes.ERC20Addr.ExactMatch(deps.Ctx, erc20Addr)
+	funTokens = deps.K.FunTokens.Collect(deps.Ctx, iter2)
+	s.Require().Len(funTokens, 1)
+	s.Require().Equal(eth.HexAddr("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477"), funTokens[0].Erc20Addr)
+	s.Require().Equal("unibi", funTokens[0].BankDenom)
+	s.Require().True(funTokens[0].IsMadeFromCoin)
+}
+
+func (s *KeeperSuite) TestDelete() {
+	deps := evmtest.NewTestDeps()
+
+	erc20Addr := gethcommon.HexToAddress("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477")
+	err := deps.K.FunTokens.SafeInsert(
+		deps.Ctx,
+		erc20Addr,
+		"unibi",
+		true,
+	)
+	s.Require().NoError(err)
+
+	// test Delete
+	err = deps.K.FunTokens.Delete(deps.Ctx, evm.NewFunTokenID(erc20Addr, "unibi"))
+	s.Require().NoError(err)
+
+	// test Get
+	_, err = deps.K.FunTokens.Get(deps.Ctx, evm.NewFunTokenID(erc20Addr, "unibi"))
+	s.Require().Error(err)
+}

From 944d4c0f22f75061c697a8ae0fc1e40e9dd54bb2 Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 09:46:16 -0700
Subject: [PATCH 07/17] add hex addr string test

---
 eth/hex_test.go | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/eth/hex_test.go b/eth/hex_test.go
index 8d11fafce..0fef9f855 100644
--- a/eth/hex_test.go
+++ b/eth/hex_test.go
@@ -270,3 +270,12 @@ func (s *Suite) TestProtobufEncoding() {
 		})
 	}
 }
+
+func (s *Suite) TestHexAddrToString() {
+	hexAddr := eth.HexAddr("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed")
+	s.Equal("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed", hexAddr.String())
+	s.Equal("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed", string(hexAddr))
+
+	ethAddr := gethcommon.HexToAddress("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed")
+	s.Equal("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed", ethAddr.String())
+}

From 870e35c469e5122457c2a9db1cfdc038c3ad5606 Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 09:46:28 -0700
Subject: [PATCH 08/17] refactor: remove EthAddr alias type

---
 eth/hex.go                |  4 ++--
 eth/state_encoder.go      | 21 +++++++++------------
 eth/state_encoder_test.go |  4 ++--
 x/evm/keeper/evm_state.go |  4 ++--
 4 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/eth/hex.go b/eth/hex.go
index e70a26efb..4f4017bc5 100644
--- a/eth/hex.go
+++ b/eth/hex.go
@@ -16,7 +16,7 @@ type HexAddr string
 
 var _ sdk.CustomProtobufType = (*HexAddr)(nil)
 
-func NewHexAddr(addr EthAddr) HexAddr {
+func NewHexAddr(addr gethcommon.Address) HexAddr {
 	return HexAddr(addr.Hex())
 }
 
@@ -58,7 +58,7 @@ func (h HexAddr) Valid() error {
 	return nil
 }
 
-func (h HexAddr) ToAddr() EthAddr {
+func (h HexAddr) ToAddr() gethcommon.Address {
 	return gethcommon.HexToAddress(string(h))
 }
 
diff --git a/eth/state_encoder.go b/eth/state_encoder.go
index 205ab7097..e77a99256 100644
--- a/eth/state_encoder.go
+++ b/eth/state_encoder.go
@@ -12,9 +12,6 @@ func BytesToHex(bz []byte) string {
 	return fmt.Sprintf("%x", bz)
 }
 
-// EthAddr: (alias) 20 byte address of an Ethereum account.
-type EthAddr = gethcommon.Address
-
 // EthHash: (alias) 32 byte Keccak256 hash of arbitrary data.
 type EthHash = gethcommon.Hash //revive:disable-line:exported
 
@@ -24,9 +21,9 @@ var (
 	KeyEncoderBytes   collections.KeyEncoder[[]byte]   = keBytes{}
 
 	// Implements a `collections.ValueEncoder` for an Ethereum address.
-	ValueEncoderEthAddr collections.ValueEncoder[EthAddr] = veEthAddr{}
+	ValueEncoderEthAddr collections.ValueEncoder[gethcommon.Address] = veEthAddr{}
 	// keEthHash: Implements a `collections.KeyEncoder` for an Ethereum address.
-	KeyEncoderEthAddr collections.KeyEncoder[EthAddr] = keEthAddr{}
+	KeyEncoderEthAddr collections.KeyEncoder[gethcommon.Address] = keEthAddr{}
 
 	// keEthHash: Implements a `collections.KeyEncoder` for an Ethereum hash.
 	KeyEncoderEthHash collections.KeyEncoder[EthHash] = keEthHash{}
@@ -43,10 +40,10 @@ func (_ veBytes) Name() string                  { return "[]byte" }
 // veEthAddr: Implements a `collections.ValueEncoder` for an Ethereum address.
 type veEthAddr struct{}
 
-func (_ veEthAddr) Encode(value EthAddr) []byte    { return value.Bytes() }
-func (_ veEthAddr) Decode(bz []byte) EthAddr       { return gethcommon.BytesToAddress(bz) }
-func (_ veEthAddr) Stringify(value EthAddr) string { return value.Hex() }
-func (_ veEthAddr) Name() string                   { return "EthAddr" }
+func (_ veEthAddr) Encode(value gethcommon.Address) []byte    { return value.Bytes() }
+func (_ veEthAddr) Decode(bz []byte) gethcommon.Address       { return gethcommon.BytesToAddress(bz) }
+func (_ veEthAddr) Stringify(value gethcommon.Address) string { return value.Hex() }
+func (_ veEthAddr) Name() string                              { return "gethcommon.Address" }
 
 type keBytes struct{}
 
@@ -63,11 +60,11 @@ func (_ keBytes) Stringify(key []byte) string { return BytesToHex(key) }
 // keEthAddr: Implements a `collections.KeyEncoder` for an Ethereum address.
 type keEthAddr struct{}
 
-func (_ keEthAddr) Encode(value EthAddr) []byte { return value.Bytes() }
-func (_ keEthAddr) Decode(bz []byte) (int, EthAddr) {
+func (_ keEthAddr) Encode(value gethcommon.Address) []byte { return value.Bytes() }
+func (_ keEthAddr) Decode(bz []byte) (int, gethcommon.Address) {
 	return gethcommon.AddressLength, gethcommon.BytesToAddress(bz)
 }
-func (_ keEthAddr) Stringify(value EthAddr) string { return value.Hex() }
+func (_ keEthAddr) Stringify(value gethcommon.Address) string { return value.Hex() }
 
 // keEthHash: Implements a `collections.KeyEncoder` for an Ethereum hash.
 type keEthHash struct{}
diff --git a/eth/state_encoder_test.go b/eth/state_encoder_test.go
index 02d5a8f89..03eff2ac6 100644
--- a/eth/state_encoder_test.go
+++ b/eth/state_encoder_test.go
@@ -64,7 +64,7 @@ func (s *Suite) TestEncoderBytes() {
 func (s *Suite) TestEncoderEthAddr() {
 	testCases := []struct {
 		name      string
-		given     eth.EthAddr
+		given     gethcommon.Address
 		wantPanic bool
 	}{
 		{
@@ -77,7 +77,7 @@ func (s *Suite) TestEncoderEthAddr() {
 		},
 		{
 			name:  "Nibiru Bech 32 addr (hypothetically)",
-			given: eth.EthAddr([]byte("nibi1rlvdjfmxkyfj4tzu73p8m4g2h4y89xccf9622l")),
+			given: gethcommon.Address([]byte("nibi1rlvdjfmxkyfj4tzu73p8m4g2h4y89xccf9622l")),
 		},
 	}
 	for _, tc := range testCases {
diff --git a/x/evm/keeper/evm_state.go b/x/evm/keeper/evm_state.go
index 0f0013f1c..c35205052 100644
--- a/x/evm/keeper/evm_state.go
+++ b/x/evm/keeper/evm_state.go
@@ -130,7 +130,7 @@ func (k Keeper) SetParams(ctx sdk.Context, params evm.Params) {
 
 // SetState updates contract storage and deletes if the value is empty.
 func (state EvmState) SetAccState(
-	ctx sdk.Context, addr eth.EthAddr, stateKey eth.EthHash, stateValue []byte,
+	ctx sdk.Context, addr gethcommon.Address, stateKey eth.EthHash, stateValue []byte,
 ) {
 	if len(stateValue) != 0 {
 		state.AccState.Insert(ctx, collections.Join(addr, stateKey), stateValue)
@@ -140,7 +140,7 @@ func (state EvmState) SetAccState(
 }
 
 // GetState: Implements `statedb.Keeper` interface: Loads smart contract state.
-func (k *Keeper) GetState(ctx sdk.Context, addr eth.EthAddr, stateKey eth.EthHash) eth.EthHash {
+func (k *Keeper) GetState(ctx sdk.Context, addr gethcommon.Address, stateKey eth.EthHash) eth.EthHash {
 	return gethcommon.BytesToHash(k.EvmState.AccState.GetOr(
 		ctx,
 		collections.Join(addr, stateKey),

From 7378486f8f9a6196ea533c9c23cd71fdca4c5c87 Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 09:47:59 -0700
Subject: [PATCH 09/17] refactor: remove EthHash alias type

---
 eth/state_encoder.go      | 11 ++++-------
 x/evm/keeper/evm_state.go |  4 ++--
 2 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/eth/state_encoder.go b/eth/state_encoder.go
index e77a99256..bb3fbaef6 100644
--- a/eth/state_encoder.go
+++ b/eth/state_encoder.go
@@ -12,9 +12,6 @@ func BytesToHex(bz []byte) string {
 	return fmt.Sprintf("%x", bz)
 }
 
-// EthHash: (alias) 32 byte Keccak256 hash of arbitrary data.
-type EthHash = gethcommon.Hash //revive:disable-line:exported
-
 var (
 	// Implements a `collections.ValueEncoder` for the `[]byte` type
 	ValueEncoderBytes collections.ValueEncoder[[]byte] = veBytes{}
@@ -26,7 +23,7 @@ var (
 	KeyEncoderEthAddr collections.KeyEncoder[gethcommon.Address] = keEthAddr{}
 
 	// keEthHash: Implements a `collections.KeyEncoder` for an Ethereum hash.
-	KeyEncoderEthHash collections.KeyEncoder[EthHash] = keEthHash{}
+	KeyEncoderEthHash collections.KeyEncoder[gethcommon.Hash] = keEthHash{}
 )
 
 // collections ValueEncoder[[]byte]
@@ -69,8 +66,8 @@ func (_ keEthAddr) Stringify(value gethcommon.Address) string { return value.Hex
 // keEthHash: Implements a `collections.KeyEncoder` for an Ethereum hash.
 type keEthHash struct{}
 
-func (_ keEthHash) Encode(value EthHash) []byte { return value.Bytes() }
-func (_ keEthHash) Decode(bz []byte) (int, EthHash) {
+func (_ keEthHash) Encode(value gethcommon.Hash) []byte { return value.Bytes() }
+func (_ keEthHash) Decode(bz []byte) (int, gethcommon.Hash) {
 	return gethcommon.HashLength, gethcommon.BytesToHash(bz)
 }
-func (_ keEthHash) Stringify(value EthHash) string { return value.Hex() }
+func (_ keEthHash) Stringify(value gethcommon.Hash) string { return value.Hex() }
diff --git a/x/evm/keeper/evm_state.go b/x/evm/keeper/evm_state.go
index c35205052..318beb4d8 100644
--- a/x/evm/keeper/evm_state.go
+++ b/x/evm/keeper/evm_state.go
@@ -130,7 +130,7 @@ func (k Keeper) SetParams(ctx sdk.Context, params evm.Params) {
 
 // SetState updates contract storage and deletes if the value is empty.
 func (state EvmState) SetAccState(
-	ctx sdk.Context, addr gethcommon.Address, stateKey eth.EthHash, stateValue []byte,
+	ctx sdk.Context, addr gethcommon.Address, stateKey gethcommon.Hash, stateValue []byte,
 ) {
 	if len(stateValue) != 0 {
 		state.AccState.Insert(ctx, collections.Join(addr, stateKey), stateValue)
@@ -140,7 +140,7 @@ func (state EvmState) SetAccState(
 }
 
 // GetState: Implements `statedb.Keeper` interface: Loads smart contract state.
-func (k *Keeper) GetState(ctx sdk.Context, addr gethcommon.Address, stateKey eth.EthHash) eth.EthHash {
+func (k *Keeper) GetState(ctx sdk.Context, addr gethcommon.Address, stateKey gethcommon.Hash) gethcommon.Hash {
 	return gethcommon.BytesToHash(k.EvmState.AccState.GetOr(
 		ctx,
 		collections.Join(addr, stateKey),

From 7e1e5b2fc6244af44a32466e2f97041c8f50b590 Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 09:49:40 -0700
Subject: [PATCH 10/17] refactor: remove extra types

---
 x/evm/keeper/funtoken_state.go | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/x/evm/keeper/funtoken_state.go b/x/evm/keeper/funtoken_state.go
index c713c1fc3..2833eb597 100644
--- a/x/evm/keeper/funtoken_state.go
+++ b/x/evm/keeper/funtoken_state.go
@@ -10,19 +10,13 @@ import (
 
 	"github.com/NibiruChain/nibiru/eth"
 	"github.com/NibiruChain/nibiru/x/evm"
-	funtoken "github.com/NibiruChain/nibiru/x/evm"
-)
-
-type (
-	funtokenPrimaryKeyType = []byte
-	funtokenValueType      = funtoken.FunToken
 )
 
 // FunTokenState isolates the key-value stores (collections) for fungible token
 // mappings. This struct is written as an extension of the default indexed map to
 // add utility functions.
 type FunTokenState struct {
-	collections.IndexedMap[funtokenPrimaryKeyType, funtokenValueType, IndexesFunToken]
+	collections.IndexedMap[[]byte, evm.FunToken, IndexesFunToken]
 }
 
 func NewFunTokenState(
@@ -30,7 +24,7 @@ func NewFunTokenState(
 	storeKey storetypes.StoreKey,
 ) FunTokenState {
 	primaryKeyEncoder := eth.KeyEncoderBytes
-	valueEncoder := collections.ProtoValueEncoder[funtokenValueType](cdc)
+	valueEncoder := collections.ProtoValueEncoder[evm.FunToken](cdc)
 	idxMap := collections.NewIndexedMap(
 		storeKey, evm.KeyPrefixFunTokens, primaryKeyEncoder, valueEncoder,
 		IndexesFunToken{
@@ -53,8 +47,8 @@ func NewFunTokenState(
 	return FunTokenState{IndexedMap: idxMap}
 }
 
-func (idxs IndexesFunToken) IndexerList() []collections.Indexer[funtokenPrimaryKeyType, funtokenValueType] {
-	return []collections.Indexer[funtokenPrimaryKeyType, funtokenValueType]{
+func (idxs IndexesFunToken) IndexerList() []collections.Indexer[[]byte, evm.FunToken] {
+	return []collections.Indexer[[]byte, evm.FunToken]{
 		idxs.ERC20Addr,
 		idxs.BankDenom,
 	}
@@ -66,13 +60,13 @@ type IndexesFunToken struct {
 	//  - indexing key (IK): ERC-20 addr
 	//  - primary key (PK): FunToken ID
 	//  - value (V): FunToken value
-	ERC20Addr collections.MultiIndex[gethcommon.Address, funtokenPrimaryKeyType, funtokenValueType]
+	ERC20Addr collections.MultiIndex[gethcommon.Address, []byte, evm.FunToken]
 
 	// BankDenom (MultiIndex): Index FunToken by coin denomination
 	//  - indexing key (IK): Coin denom
 	//  - primary key (PK): FunToken ID
 	//  - value (V): FunToken value
-	BankDenom collections.MultiIndex[string, funtokenPrimaryKeyType, funtokenValueType]
+	BankDenom collections.MultiIndex[string, []byte, evm.FunToken]
 }
 
 // Insert adds an [evm.FunToken] to state with defensive validation. Errors if

From d2d745a7584836fb5047cf1a98e1071531c5964d Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 09:52:09 -0700
Subject: [PATCH 11/17] refactor: FunToken ID generation

---
 x/evm/evm.go | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/x/evm/evm.go b/x/evm/evm.go
index 08612c9d9..daaf2c059 100644
--- a/x/evm/evm.go
+++ b/x/evm/evm.go
@@ -15,29 +15,24 @@ import (
 // tokens that are valid ERC20s with the same address.
 // https://github.com/NibiruChain/nibiru/issues/1933
 func (fun FunToken) ID() []byte {
-	return newFunTokenIDFromStr(fun.Erc20Addr.String(), fun.BankDenom)
+	return NewFunTokenID(fun.Erc20Addr, fun.BankDenom)
 }
 
-func NewFunTokenID(erc20 gethcommon.Address, bankDenom string) []byte {
-	erc20Addr := erc20.Hex()
-	return newFunTokenIDFromStr(erc20Addr, bankDenom)
+func NewFunTokenID(erc20 eth.HexAddr, bankDenom string) []byte {
+	return tmhash.Sum([]byte(erc20.String() + "|" + bankDenom))
 }
 
-func newFunTokenIDFromStr(erc20AddrHex string, bankDenom string) []byte {
-	return tmhash.Sum([]byte(erc20AddrHex + "|" + bankDenom))
-}
-
-func errValidateFunToken(errMsg string) error {
-	return fmt.Errorf("FunTokenError: %s", errMsg)
+func funTokenValidationError(err error) error {
+	return fmt.Errorf("FunTokenError: %s", err.Error())
 }
 
 func (fun FunToken) Validate() error {
 	if err := sdk.ValidateDenom(fun.BankDenom); err != nil {
-		return errValidateFunToken(err.Error())
+		return funTokenValidationError(err)
 	}
 
 	if err := fun.Erc20Addr.Valid(); err != nil {
-		return errValidateFunToken(err.Error())
+		return funTokenValidationError(err)
 	}
 
 	return nil

From 325a2e48bc897cde5424a23db7608ed8e30371da Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 09:52:17 -0700
Subject: [PATCH 12/17] fix: test fun token state

---
 x/evm/keeper/funtoken_state_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/x/evm/keeper/funtoken_state_test.go b/x/evm/keeper/funtoken_state_test.go
index ee9e4c928..122e3f409 100644
--- a/x/evm/keeper/funtoken_state_test.go
+++ b/x/evm/keeper/funtoken_state_test.go
@@ -21,7 +21,7 @@ func (s *KeeperSuite) TestInsertAndGet() {
 	s.Require().NoError(err)
 
 	// test Get
-	funToken, err := deps.K.FunTokens.Get(deps.Ctx, evm.NewFunTokenID(erc20Addr, "unibi"))
+	funToken, err := deps.K.FunTokens.Get(deps.Ctx, evm.NewFunTokenID(eth.NewHexAddr(erc20Addr), "unibi"))
 	s.Require().NoError(err)
 	s.Require().Equal(eth.HexAddr("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477"), funToken.Erc20Addr)
 	s.Require().Equal("unibi", funToken.BankDenom)
@@ -73,10 +73,10 @@ func (s *KeeperSuite) TestDelete() {
 	s.Require().NoError(err)
 
 	// test Delete
-	err = deps.K.FunTokens.Delete(deps.Ctx, evm.NewFunTokenID(erc20Addr, "unibi"))
+	err = deps.K.FunTokens.Delete(deps.Ctx, evm.NewFunTokenID(eth.NewHexAddr(erc20Addr), "unibi"))
 	s.Require().NoError(err)
 
 	// test Get
-	_, err = deps.K.FunTokens.Get(deps.Ctx, evm.NewFunTokenID(erc20Addr, "unibi"))
+	_, err = deps.K.FunTokens.Get(deps.Ctx, evm.NewFunTokenID(eth.NewHexAddr(erc20Addr), "unibi"))
 	s.Require().Error(err)
 }

From f3ac2f0468b6fa33130bf2347df4669c91db6bd5 Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 09:53:50 -0700
Subject: [PATCH 13/17] Update CHANGELOG.md

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5694d65ed..1903de5ff 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -77,6 +77,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - [#1917](https://github.com/NibiruChain/nibiru/pull/1917) - test(e2e-evm): TypeScript support. Type generation from compiled contracts. Formatter for TS code.
 - [#1922](https://github.com/NibiruChain/nibiru/pull/1922) - feat(evm): tracer option is read from the config.
 - [#1936](https://github.com/NibiruChain/nibiru/pull/1936) - feat(evm): EVM fungible token protobufs and encoding tests
+- [#1947](https://github.com/NibiruChain/nibiru/pull/1947) - fix(evm): fix FunToken state marshalling
 
 #### Dapp modules: perp, spot, oracle, etc
 

From bdb042dd99df80085080831c9d34214206c3688f Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 10:01:26 -0700
Subject: [PATCH 14/17] refactor: use token id for token mapping query

---
 proto/eth/evm/v1/query.proto    |   8 +-
 x/evm/keeper/grpc_query.go      |   4 +-
 x/evm/keeper/grpc_query_test.go |  20 +--
 x/evm/query.pb.go               | 212 ++++++++++++++++----------------
 x/evm/query.pb.gw.go            |  18 +--
 5 files changed, 133 insertions(+), 129 deletions(-)

diff --git a/proto/eth/evm/v1/query.proto b/proto/eth/evm/v1/query.proto
index e71083b29..e0dbff12a 100644
--- a/proto/eth/evm/v1/query.proto
+++ b/proto/eth/evm/v1/query.proto
@@ -77,7 +77,7 @@ service Query {
   }
 
   rpc TokenMapping(QueryTokenMappingRequest) returns (QueryTokenMappingResponse) {
-    option (google.api.http).get = "/nibiru/evm/v1/token_mapping/{token}";
+    option (google.api.http).get = "/nibiru/evm/v1/token_mapping/{token_id}";
   }
 }
 
@@ -310,9 +310,9 @@ message QueryTokenMappingRequest {
   option (gogoproto.equal) = false;
   option (gogoproto.goproto_getters) = false;
 
-  // token identifier can be either the hex contract address of the ERC20 or the
-	// Cosmos base denomination
-  string token = 1;
+  // token identifier which is a sha256 sum of the erc20 address concatenated with the cosmos denom
+  // see `NewFunTokenID()` for more details
+  string token_id = 1;
 }
 
 message QueryTokenMappingResponse {
diff --git a/x/evm/keeper/grpc_query.go b/x/evm/keeper/grpc_query.go
index a0dad4a3e..1b572eeb2 100644
--- a/x/evm/keeper/grpc_query.go
+++ b/x/evm/keeper/grpc_query.go
@@ -746,9 +746,9 @@ func (k Keeper) TokenMapping(
 ) (*evm.QueryTokenMappingResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
-	funToken, err := k.FunTokens.Get(ctx, []byte(req.Token))
+	funToken, err := k.FunTokens.Get(ctx, []byte(req.TokenId))
 	if err != nil {
-		return nil, grpcstatus.Errorf(grpccodes.NotFound, "token not found for %s", req.Token)
+		return nil, grpcstatus.Errorf(grpccodes.NotFound, "token mapping not found for %s", req.TokenId)
 	}
 
 	return &evm.QueryTokenMappingResponse{
diff --git a/x/evm/keeper/grpc_query_test.go b/x/evm/keeper/grpc_query_test.go
index 79fbb4ed5..3dd5e7e51 100644
--- a/x/evm/keeper/grpc_query_test.go
+++ b/x/evm/keeper/grpc_query_test.go
@@ -903,27 +903,31 @@ func (s *KeeperSuite) TestQueryTokenMapping() {
 			name: "sad: no token mapping",
 			scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) {
 				req = &evm.QueryTokenMappingRequest{
-					Token: "unibi",
+					TokenId: string(evm.NewFunTokenID(eth.MustNewHexAddrFromStr("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477"), "unibi")),
 				}
 				wantResp = &evm.QueryTokenMappingResponse{
 					FunToken: nil,
 				}
 				return req, wantResp
 			},
-			wantErr: "token not found for unibi",
+			wantErr: "token mapping not found for",
 		},
 		{
 			name: "happy: token mapping exists from cosmos coin -> ERC20 token",
 			setup: func(deps *evmtest.TestDeps) {
-				deps.K.FunTokens.Insert(deps.Ctx, []byte("unibi"), evm.FunToken{
-					Erc20Addr:      "0xAEf9437FF23D48D73271a41a8A094DEc9ac71477",
-					BankDenom:      "unibi",
-					IsMadeFromCoin: true,
-				})
+				erc20Addr := eth.MustNewHexAddrFromStr("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477")
+				deps.K.FunTokens.Insert(deps.Ctx,
+					evm.NewFunTokenID(erc20Addr, "unibi"),
+					evm.FunToken{
+						Erc20Addr:      "0xAEf9437FF23D48D73271a41a8A094DEc9ac71477",
+						BankDenom:      "unibi",
+						IsMadeFromCoin: true,
+					},
+				)
 			},
 			scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) {
 				req = &evm.QueryTokenMappingRequest{
-					Token: "unibi",
+					TokenId: string(evm.NewFunTokenID(eth.MustNewHexAddrFromStr("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477"), "unibi")),
 				}
 				wantResp = &evm.QueryTokenMappingResponse{
 					FunToken: &evm.FunToken{
diff --git a/x/evm/query.pb.go b/x/evm/query.pb.go
index dd77928fc..0ba945207 100644
--- a/x/evm/query.pb.go
+++ b/x/evm/query.pb.go
@@ -1304,9 +1304,9 @@ func (m *QueryBaseFeeResponse) XXX_DiscardUnknown() {
 var xxx_messageInfo_QueryBaseFeeResponse proto.InternalMessageInfo
 
 type QueryTokenMappingRequest struct {
-	// token identifier can be either the hex contract address of the ERC20 or the
-	// Cosmos base denomination
-	Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
+	// token identifier which is a sha256 sum of the erc20 address concatenated with the cosmos denom
+	// see `NewFunTokenID()` for more details
+	TokenId string `protobuf:"bytes,1,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"`
 }
 
 func (m *QueryTokenMappingRequest) Reset()         { *m = QueryTokenMappingRequest{} }
@@ -1412,104 +1412,104 @@ func init() {
 func init() { proto.RegisterFile("eth/evm/v1/query.proto", fileDescriptor_ffa36cdc5add14ed) }
 
 var fileDescriptor_ffa36cdc5add14ed = []byte{
-	// 1544 bytes of a gzipped FileDescriptorProto
+	// 1550 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0x4d, 0x6f, 0x1b, 0x55,
 	0x17, 0xce, 0xc4, 0x4e, 0xec, 0x1c, 0xa7, 0x6d, 0xde, 0xdb, 0xb4, 0x49, 0xa6, 0x89, 0x9d, 0x4e,
-	0xda, 0x24, 0xed, 0xdb, 0xce, 0x34, 0x01, 0x81, 0xa8, 0xa8, 0x50, 0x13, 0xa5, 0xa1, 0xf4, 0x43,
-	0xc5, 0x44, 0x08, 0x21, 0x21, 0xeb, 0xda, 0xbe, 0x19, 0x8f, 0xe2, 0x99, 0xeb, 0xce, 0xbd, 0x0e,
-	0x0e, 0x25, 0x1b, 0xba, 0x01, 0xb1, 0xa0, 0x12, 0x7f, 0xa0, 0x2b, 0xfe, 0x02, 0x7f, 0xa1, 0xcb,
-	0x22, 0x36, 0x88, 0x45, 0x41, 0x2d, 0x0b, 0xd6, 0x2c, 0x59, 0xa1, 0xfb, 0x31, 0xf1, 0x8c, 0x3d,
-	0x4e, 0x28, 0x1f, 0x3b, 0x56, 0x33, 0xf7, 0xde, 0x73, 0xce, 0xf3, 0x9c, 0xfb, 0x71, 0xce, 0x03,
-	0xa7, 0x09, 0x6f, 0x38, 0x64, 0xd7, 0x77, 0x76, 0x57, 0x9c, 0xfb, 0x6d, 0x12, 0xee, 0xd9, 0xad,
-	0x90, 0x72, 0x8a, 0x80, 0xf0, 0x86, 0x4d, 0x76, 0x7d, 0x7b, 0x77, 0xc5, 0xbc, 0x58, 0xa3, 0xcc,
-	0xa7, 0xcc, 0xa9, 0x62, 0x46, 0x94, 0x91, 0xb3, 0xbb, 0x52, 0x25, 0x1c, 0xaf, 0x38, 0x2d, 0xec,
-	0x7a, 0x01, 0xe6, 0x1e, 0x0d, 0x94, 0x9f, 0x39, 0x19, 0x8b, 0x27, 0xdc, 0xd5, 0xec, 0xc9, 0xd8,
-	0x2c, 0xef, 0x44, 0xa6, 0x2e, 0x75, 0xa9, 0xfc, 0x75, 0xc4, 0x9f, 0x9e, 0x9d, 0x75, 0x29, 0x75,
-	0x9b, 0xc4, 0xc1, 0x2d, 0xcf, 0xc1, 0x41, 0x40, 0xb9, 0x8c, 0xce, 0xf4, 0x6a, 0x49, 0xaf, 0xca,
-	0x51, 0xb5, 0xbd, 0xed, 0x70, 0xcf, 0x27, 0x8c, 0x63, 0xbf, 0xa5, 0x0c, 0xac, 0x37, 0xe1, 0xf4,
-	0xbb, 0x82, 0xe1, 0x06, 0x6f, 0x5c, 0xaf, 0xd5, 0x68, 0x3b, 0xe0, 0x65, 0x72, 0xbf, 0x4d, 0x18,
-	0x47, 0xd3, 0x90, 0xc3, 0xf5, 0x7a, 0x48, 0x18, 0x9b, 0x36, 0xe6, 0x8d, 0xe5, 0xb1, 0x72, 0x34,
-	0xbc, 0x9a, 0xff, 0xfc, 0x71, 0x69, 0xe8, 0xd7, 0xc7, 0xa5, 0x21, 0x6b, 0x1b, 0xa6, 0xfa, 0xbc,
-	0x59, 0x8b, 0x06, 0x8c, 0x08, 0xf7, 0x2a, 0x6e, 0xe2, 0xa0, 0x46, 0x22, 0x77, 0x3d, 0x44, 0x67,
-	0x60, 0xac, 0x46, 0xeb, 0xa4, 0xd2, 0xc0, 0xac, 0x31, 0x3d, 0x2c, 0xd7, 0xf2, 0x62, 0xe2, 0x6d,
-	0xcc, 0x1a, 0x68, 0x12, 0x46, 0x02, 0x2a, 0x9c, 0x32, 0xf3, 0xc6, 0x72, 0xb6, 0xac, 0x06, 0xd6,
-	0x5b, 0x30, 0x23, 0x71, 0xee, 0x7a, 0x55, 0x2f, 0x6c, 0xff, 0x05, 0xa2, 0x7b, 0x60, 0xa6, 0x05,
-	0xe8, 0x72, 0x4d, 0x8f, 0x80, 0x4c, 0xc8, 0x33, 0x01, 0x23, 0x18, 0x0d, 0x4b, 0x46, 0x07, 0x63,
-	0x74, 0x1e, 0x8e, 0x63, 0x15, 0xa8, 0x12, 0xb4, 0xfd, 0x2a, 0x09, 0x35, 0xe7, 0x63, 0x7a, 0xf6,
-	0xae, 0x9c, 0xb4, 0x6e, 0xc1, 0xac, 0x84, 0x7e, 0x1f, 0x37, 0xbd, 0x3a, 0xe6, 0x34, 0xec, 0xa1,
-	0x7f, 0x16, 0xc6, 0x6b, 0x34, 0x60, 0x95, 0x24, 0x83, 0x82, 0x98, 0xbb, 0xde, 0x97, 0xc7, 0x97,
-	0x06, 0xcc, 0x0d, 0x88, 0xa6, 0x73, 0x59, 0x82, 0x13, 0x11, 0xab, 0x64, 0xc4, 0x88, 0xec, 0xf5,
-	0x7f, 0x2e, 0xb5, 0x37, 0xe0, 0xa4, 0x24, 0xb3, 0xa6, 0x4e, 0xf6, 0x65, 0x0e, 0xe4, 0x0a, 0x4c,
-	0x26, 0x5d, 0x8f, 0xba, 0x36, 0xd6, 0x2d, 0x0d, 0xf6, 0x1e, 0xa7, 0x21, 0x76, 0x8f, 0x06, 0x43,
-	0x13, 0x90, 0xd9, 0x21, 0x7b, 0xfa, 0x86, 0x89, 0xdf, 0x18, 0xfc, 0x25, 0x0d, 0x7f, 0x10, 0x4c,
-	0xc3, 0x4f, 0xc2, 0xc8, 0x2e, 0x6e, 0xb6, 0x23, 0x70, 0x35, 0xb0, 0x5e, 0x83, 0x09, 0x69, 0xbd,
-	0x4e, 0xeb, 0x2f, 0x95, 0xe4, 0x12, 0xfc, 0x2f, 0xe6, 0xa7, 0x21, 0x10, 0x64, 0xc5, 0x6d, 0x97,
-	0x5e, 0xe3, 0x65, 0xf9, 0x6f, 0x7d, 0x02, 0x48, 0x1a, 0x6e, 0x75, 0x6e, 0x53, 0x97, 0x45, 0x10,
-	0x08, 0xb2, 0xf2, 0x8d, 0xa8, 0xf8, 0xf2, 0x1f, 0xdd, 0x00, 0xe8, 0xd6, 0x10, 0x99, 0x5b, 0x61,
-	0x75, 0xd1, 0x56, 0x05, 0xc7, 0x16, 0x05, 0xc7, 0x56, 0x55, 0x49, 0x17, 0x1c, 0xfb, 0x5e, 0x77,
-	0xab, 0xca, 0x31, 0xcf, 0x18, 0xc9, 0x87, 0x86, 0xde, 0xd8, 0x08, 0x5c, 0xf3, 0x5c, 0x80, 0x6c,
-	0x93, 0xba, 0x22, 0xbb, 0xcc, 0x72, 0x61, 0xf5, 0x84, 0xdd, 0x2d, 0x70, 0xf6, 0x6d, 0xea, 0x96,
-	0xe5, 0x22, 0xda, 0x4c, 0xa1, 0xb3, 0x74, 0x24, 0x1d, 0x85, 0x10, 0xe7, 0x63, 0x4d, 0xea, 0x1d,
-	0xb8, 0x87, 0x43, 0xec, 0x47, 0x3b, 0x60, 0x6d, 0x6a, 0x6a, 0xd1, 0xac, 0xa6, 0x76, 0x05, 0x46,
-	0x5b, 0x72, 0x46, 0x6e, 0x4d, 0x61, 0x15, 0xc5, 0xc9, 0x29, 0xdb, 0xb5, 0xec, 0x93, 0x67, 0xa5,
-	0xa1, 0xb2, 0xb6, 0xb3, 0xbe, 0x35, 0xe0, 0xf8, 0x06, 0x6f, 0xac, 0xe3, 0x66, 0x33, 0xb6, 0xbb,
-	0x38, 0x74, 0x59, 0x74, 0x0e, 0xe2, 0x1f, 0x4d, 0x41, 0xce, 0xc5, 0xac, 0x52, 0xc3, 0x2d, 0xfd,
-	0x24, 0x46, 0x5d, 0xcc, 0xd6, 0x71, 0x0b, 0x7d, 0x04, 0x13, 0xad, 0x90, 0xb6, 0x28, 0x23, 0xe1,
-	0xc1, 0xb3, 0x12, 0x4f, 0x62, 0x7c, 0x6d, 0xf5, 0xf7, 0x67, 0x25, 0xdb, 0xf5, 0x78, 0xa3, 0x5d,
-	0xb5, 0x6b, 0xd4, 0x77, 0x74, 0xed, 0x57, 0x9f, 0xcb, 0xac, 0xbe, 0xe3, 0xf0, 0xbd, 0x16, 0x61,
-	0xf6, 0x7a, 0xf7, 0x3d, 0x97, 0x4f, 0x44, 0xb1, 0xa2, 0xb7, 0x38, 0x03, 0xf9, 0x5a, 0x03, 0x7b,
-	0x41, 0xc5, 0xab, 0x4f, 0x67, 0xe7, 0x8d, 0xe5, 0x4c, 0x39, 0x27, 0xc7, 0x37, 0xeb, 0xd6, 0x12,
-	0x9c, 0xdc, 0x60, 0xdc, 0xf3, 0x31, 0x27, 0x9b, 0xb8, 0xbb, 0x05, 0x13, 0x90, 0x71, 0xb1, 0x22,
-	0x9f, 0x2d, 0x8b, 0x5f, 0xeb, 0xb7, 0x4c, 0x74, 0x8e, 0x21, 0xae, 0x91, 0xad, 0x4e, 0x94, 0xe7,
-	0xff, 0x21, 0xe3, 0x33, 0x57, 0xef, 0xd4, 0x4c, 0x7c, 0xa7, 0xee, 0x30, 0x77, 0x83, 0x37, 0x48,
-	0x48, 0xda, 0xfe, 0x56, 0xa7, 0x2c, 0xac, 0xd0, 0x55, 0x18, 0xe7, 0xc2, 0xbd, 0x52, 0xa3, 0xc1,
-	0xb6, 0xe7, 0xca, 0x1c, 0x0b, 0xab, 0x53, 0x71, 0x2f, 0x19, 0x7e, 0x5d, 0x2e, 0x97, 0x0b, 0xbc,
-	0x3b, 0x40, 0xd7, 0x60, 0xbc, 0x15, 0x92, 0x3a, 0xa9, 0x11, 0xc6, 0x68, 0xc8, 0xa6, 0xb3, 0xf2,
-	0xe2, 0x1c, 0x82, 0x98, 0x30, 0x17, 0x75, 0xb0, 0xda, 0xa4, 0xb5, 0x9d, 0xa8, 0xe2, 0x8c, 0xc8,
-	0x7d, 0x28, 0xc8, 0x39, 0x55, 0x6f, 0xd0, 0x1c, 0x80, 0x32, 0x91, 0xcf, 0x62, 0x54, 0x3e, 0x8b,
-	0x31, 0x39, 0x23, 0x7b, 0xc7, 0x7a, 0xb4, 0x2c, 0x9a, 0xdc, 0x74, 0x4e, 0x52, 0x37, 0x6d, 0xd5,
-	0x01, 0xed, 0xa8, 0x03, 0xda, 0x5b, 0x51, 0x07, 0x5c, 0xcb, 0x8b, 0x2b, 0xf2, 0xe8, 0xa7, 0x92,
-	0xa1, 0x83, 0x88, 0x95, 0xd4, 0x93, 0xce, 0xff, 0x3b, 0x27, 0x3d, 0x96, 0x38, 0x69, 0x64, 0xc1,
-	0x31, 0x45, 0xdf, 0xc7, 0x9d, 0x8a, 0x38, 0x5c, 0x88, 0xed, 0xc0, 0x1d, 0xdc, 0xd9, 0xc4, 0xec,
-	0x9d, 0x6c, 0x7e, 0x78, 0x22, 0x53, 0xce, 0xf3, 0x4e, 0xc5, 0x0b, 0xea, 0xa4, 0x63, 0x5d, 0xd4,
-	0x75, 0xec, 0xe0, 0xcc, 0xbb, 0x45, 0xa6, 0x8e, 0x39, 0x8e, 0x2e, 0xb7, 0xf8, 0xb7, 0xbe, 0xc9,
-	0xe8, 0x5e, 0x2f, 0x8d, 0xd7, 0x44, 0xd4, 0xd8, 0x1d, 0xe1, 0x9d, 0xe8, 0xa9, 0x1f, 0x76, 0x47,
-	0x78, 0x87, 0xfd, 0xad, 0x3b, 0xf2, 0xdf, 0x21, 0x1f, 0x7d, 0xc8, 0xd6, 0x65, 0xad, 0xaa, 0xe2,
-	0xe7, 0x74, 0xc8, 0xb9, 0x9e, 0x3a, 0xe8, 0xc2, 0x8c, 0xdc, 0x20, 0x51, 0xb5, 0xb7, 0x6e, 0x1f,
-	0x74, 0x58, 0x3d, 0xad, 0x43, 0xbc, 0x0a, 0x79, 0x51, 0x98, 0x2b, 0xdb, 0x44, 0x77, 0xb9, 0xb5,
-	0x99, 0x1f, 0x9f, 0x95, 0x4e, 0xa9, 0x0c, 0x59, 0x7d, 0xc7, 0xf6, 0xa8, 0xe3, 0x63, 0xde, 0xb0,
-	0x6f, 0x06, 0x5c, 0x74, 0x5f, 0xe9, 0x6d, 0x5d, 0x85, 0x69, 0xc5, 0x89, 0xee, 0x90, 0xe0, 0x0e,
-	0x6e, 0xb5, 0xbc, 0xc0, 0x8d, 0x6e, 0xcf, 0x24, 0x8c, 0x70, 0x31, 0x1d, 0x35, 0x4d, 0x39, 0x88,
-	0x75, 0x98, 0x0f, 0xb4, 0x7a, 0x4b, 0xfa, 0x6a, 0x3a, 0x2b, 0x30, 0xb6, 0xdd, 0x0e, 0x2a, 0xdd,
-	0x00, 0x85, 0xd5, 0xc9, 0xf8, 0x55, 0xba, 0xd1, 0x0e, 0xa4, 0x5f, 0x39, 0xbf, 0xad, 0xff, 0xba,
-	0x91, 0x57, 0xbf, 0x1b, 0x87, 0x11, 0x19, 0x1a, 0x3d, 0x34, 0x00, 0xba, 0x2a, 0x14, 0x59, 0xf1,
-	0x10, 0xe9, 0x02, 0xd7, 0x5c, 0x38, 0xd4, 0x46, 0xd1, 0xb3, 0x2e, 0x7d, 0xf6, 0xfd, 0x2f, 0x5f,
-	0x0f, 0x2f, 0xa2, 0x73, 0x4e, 0x20, 0xa5, 0xe3, 0x81, 0x56, 0xe7, 0x8d, 0x8a, 0x16, 0x43, 0xce,
-	0x03, 0x7d, 0x85, 0xf6, 0xd1, 0x57, 0x06, 0x1c, 0x4b, 0x48, 0x4c, 0x74, 0xbe, 0x0f, 0x24, 0x4d,
-	0xc3, 0x9a, 0x8b, 0x47, 0x99, 0x69, 0x3a, 0x8e, 0xa4, 0x73, 0x01, 0x2d, 0xf5, 0xd0, 0x51, 0xa3,
-	0x14, 0x46, 0x8f, 0x0d, 0x98, 0xe8, 0xd5, 0x8a, 0x68, 0xb9, 0x0f, 0x6d, 0x80, 0x38, 0x35, 0x2f,
-	0xfc, 0x09, 0x4b, 0x4d, 0xed, 0x75, 0x49, 0x6d, 0x05, 0x39, 0x3d, 0xd4, 0x76, 0x23, 0x87, 0x2e,
-	0xbb, 0xb8, 0xde, 0xdd, 0x47, 0x1f, 0x43, 0x4e, 0xab, 0x40, 0x54, 0xea, 0x83, 0x4b, 0x4a, 0x4b,
-	0x73, 0x7e, 0xb0, 0x81, 0xa6, 0x71, 0x41, 0xd2, 0x58, 0x40, 0x67, 0x7b, 0x68, 0x68, 0x19, 0xc9,
-	0x62, 0x7b, 0xf3, 0x29, 0xe4, 0xb4, 0xfe, 0x4b, 0x01, 0x4e, 0xca, 0xcc, 0x14, 0xe0, 0x1e, 0xe9,
-	0x68, 0xd9, 0x12, 0x78, 0x19, 0x2d, 0xf6, 0x00, 0x33, 0x65, 0xd7, 0xc5, 0x75, 0x1e, 0xec, 0x90,
-	0xbd, 0x7d, 0xb4, 0x03, 0x59, 0xa1, 0x0b, 0xd1, 0x6c, 0x5f, 0xe4, 0x98, 0xcc, 0x34, 0xe7, 0x06,
-	0xac, 0x6a, 0xd0, 0x45, 0x09, 0x3a, 0x8f, 0x8a, 0x3d, 0xa0, 0x42, 0x55, 0xc6, 0x53, 0x6d, 0xc0,
-	0xa8, 0xd2, 0x45, 0xa8, 0xd8, 0x17, 0x30, 0x21, 0xb9, 0xcc, 0xd2, 0xc0, 0x75, 0x0d, 0x39, 0x27,
-	0x21, 0xa7, 0xd0, 0xa9, 0x1e, 0x48, 0xa5, 0xb4, 0x90, 0x07, 0x39, 0x2d, 0xb4, 0x90, 0x19, 0x0f,
-	0x95, 0x54, 0x5f, 0xe6, 0xd9, 0xc1, 0x4d, 0x26, 0x02, 0x2a, 0x49, 0xa0, 0x19, 0x34, 0x95, 0xf2,
-	0xf4, 0x6a, 0x22, 0x3e, 0x85, 0x42, 0x4c, 0x1a, 0x1d, 0x0a, 0x97, 0xc8, 0x2a, 0x45, 0x4f, 0x59,
-	0x0b, 0x12, 0x6c, 0x0e, 0x9d, 0xe9, 0x05, 0xd3, 0xb6, 0xa2, 0x56, 0x23, 0x1f, 0x72, 0xba, 0xd1,
-	0xa6, 0x5c, 0x98, 0xa4, 0xec, 0x4a, 0xb9, 0x30, 0x3d, 0x3d, 0x7a, 0x60, 0x7e, 0xaa, 0xb9, 0xf2,
-	0x0e, 0xda, 0x03, 0xe8, 0xb6, 0x80, 0x94, 0x92, 0xd6, 0xd7, 0xc7, 0x53, 0x4a, 0x5a, 0x7f, 0x0f,
-	0xb1, 0x2c, 0x89, 0x3b, 0x8b, 0xcc, 0x54, 0x5c, 0xd9, 0x88, 0x44, 0xa6, 0xba, 0x6f, 0xa4, 0xbe,
-	0xc9, 0x78, 0xa3, 0x49, 0x7d, 0x93, 0x89, 0x96, 0x33, 0x30, 0xd3, 0xa8, 0x0f, 0xa1, 0x2f, 0x0c,
-	0x18, 0x8f, 0x77, 0x07, 0x74, 0xae, 0x3f, 0x91, 0xfe, 0xc6, 0x63, 0x9e, 0x3f, 0xc2, 0xea, 0x88,
-	0x1a, 0x2e, 0x7b, 0x4e, 0xc5, 0x57, 0xd6, 0xce, 0x03, 0x39, 0xdc, 0x5f, 0xbb, 0xf6, 0xe4, 0x79,
-	0xd1, 0x78, 0xfa, 0xbc, 0x68, 0xfc, 0xfc, 0xbc, 0x68, 0x3c, 0x7a, 0x51, 0x1c, 0x7a, 0xfa, 0xa2,
-	0x38, 0xf4, 0xc3, 0x8b, 0xe2, 0xd0, 0x87, 0x0b, 0x31, 0x5d, 0xa0, 0xca, 0xf3, 0xba, 0xe8, 0xea,
-	0x51, 0xd4, 0x8e, 0x88, 0x5b, 0x1d, 0x95, 0x1a, 0xe4, 0x95, 0x3f, 0x02, 0x00, 0x00, 0xff, 0xff,
-	0xf0, 0xb1, 0xd3, 0x70, 0x29, 0x12, 0x00, 0x00,
+	0xda, 0x24, 0xed, 0xdb, 0xce, 0x34, 0x79, 0x5f, 0x81, 0xa8, 0xa8, 0xaa, 0x26, 0x4a, 0x43, 0xe9,
+	0x87, 0x8a, 0x89, 0x10, 0x42, 0x42, 0xd6, 0xb5, 0x7d, 0x33, 0x1e, 0xc5, 0x33, 0xd7, 0x9d, 0x7b,
+	0x1d, 0x1c, 0x4a, 0x36, 0x74, 0x83, 0x04, 0x12, 0x95, 0xf8, 0x03, 0x5d, 0xf1, 0x17, 0xf8, 0x0b,
+	0x5d, 0x56, 0x82, 0x05, 0x62, 0x51, 0x50, 0xcb, 0x82, 0x35, 0x4b, 0x56, 0xe8, 0x7e, 0x4c, 0x3c,
+	0x63, 0x8f, 0x13, 0xca, 0xc7, 0x8e, 0xd5, 0xcc, 0xbd, 0xf7, 0x9c, 0xf3, 0x3c, 0xe7, 0x7e, 0x9c,
+	0xf3, 0xc0, 0x69, 0xc2, 0x1b, 0x0e, 0xd9, 0xf5, 0x9d, 0xdd, 0x15, 0xe7, 0x41, 0x9b, 0x84, 0x7b,
+	0x76, 0x2b, 0xa4, 0x9c, 0x22, 0x20, 0xbc, 0x61, 0x93, 0x5d, 0xdf, 0xde, 0x5d, 0x31, 0x2f, 0xd6,
+	0x28, 0xf3, 0x29, 0x73, 0xaa, 0x98, 0x11, 0x65, 0xe4, 0xec, 0xae, 0x54, 0x09, 0xc7, 0x2b, 0x4e,
+	0x0b, 0xbb, 0x5e, 0x80, 0xb9, 0x47, 0x03, 0xe5, 0x67, 0x4e, 0xc6, 0xe2, 0x09, 0x77, 0x35, 0x7b,
+	0x32, 0x36, 0xcb, 0x3b, 0x91, 0xa9, 0x4b, 0x5d, 0x2a, 0x7f, 0x1d, 0xf1, 0xa7, 0x67, 0x67, 0x5d,
+	0x4a, 0xdd, 0x26, 0x71, 0x70, 0xcb, 0x73, 0x70, 0x10, 0x50, 0x2e, 0xa3, 0x33, 0xbd, 0x5a, 0xd2,
+	0xab, 0x72, 0x54, 0x6d, 0x6f, 0x3b, 0xdc, 0xf3, 0x09, 0xe3, 0xd8, 0x6f, 0x29, 0x03, 0xeb, 0x4d,
+	0x38, 0xfd, 0x8e, 0x60, 0xb8, 0xc1, 0x1b, 0x37, 0x6a, 0x35, 0xda, 0x0e, 0x78, 0x99, 0x3c, 0x68,
+	0x13, 0xc6, 0xd1, 0x34, 0xe4, 0x70, 0xbd, 0x1e, 0x12, 0xc6, 0xa6, 0x8d, 0x79, 0x63, 0x79, 0xac,
+	0x1c, 0x0d, 0xaf, 0xe6, 0x3f, 0x7b, 0x52, 0x1a, 0xfa, 0xe5, 0x49, 0x69, 0xc8, 0xda, 0x86, 0xa9,
+	0x3e, 0x6f, 0xd6, 0xa2, 0x01, 0x23, 0xc2, 0xbd, 0x8a, 0x9b, 0x38, 0xa8, 0x91, 0xc8, 0x5d, 0x0f,
+	0xd1, 0x19, 0x18, 0xab, 0xd1, 0x3a, 0xa9, 0x34, 0x30, 0x6b, 0x4c, 0x0f, 0xcb, 0xb5, 0xbc, 0x98,
+	0x78, 0x0b, 0xb3, 0x06, 0x9a, 0x84, 0x91, 0x80, 0x0a, 0xa7, 0xcc, 0xbc, 0xb1, 0x9c, 0x2d, 0xab,
+	0x81, 0x75, 0x1d, 0x66, 0x24, 0xce, 0x3d, 0xaf, 0xea, 0x85, 0xed, 0x3f, 0x41, 0x74, 0x0f, 0xcc,
+	0xb4, 0x00, 0x5d, 0xae, 0xe9, 0x11, 0x90, 0x09, 0x79, 0x26, 0x60, 0x04, 0xa3, 0x61, 0xc9, 0xe8,
+	0x60, 0x8c, 0xce, 0xc3, 0x71, 0xac, 0x02, 0x55, 0x82, 0xb6, 0x5f, 0x25, 0xa1, 0xe6, 0x7c, 0x4c,
+	0xcf, 0xde, 0x93, 0x93, 0xd6, 0x6d, 0x98, 0x95, 0xd0, 0xef, 0xe1, 0xa6, 0x57, 0xc7, 0x9c, 0x86,
+	0x3d, 0xf4, 0xcf, 0xc2, 0x78, 0x8d, 0x06, 0xac, 0x92, 0x64, 0x50, 0x10, 0x73, 0x37, 0xfa, 0xf2,
+	0xf8, 0xdc, 0x80, 0xb9, 0x01, 0xd1, 0x74, 0x2e, 0x4b, 0x70, 0x22, 0x62, 0x95, 0x8c, 0x18, 0x91,
+	0xbd, 0xf1, 0xf7, 0xa5, 0xf6, 0x06, 0x9c, 0x94, 0x64, 0xd6, 0xd4, 0xc9, 0xbe, 0xca, 0x81, 0x5c,
+	0x81, 0xc9, 0xa4, 0xeb, 0x51, 0xd7, 0xc6, 0xba, 0xad, 0xc1, 0xde, 0xe5, 0x34, 0xc4, 0xee, 0xd1,
+	0x60, 0x68, 0x02, 0x32, 0x3b, 0x64, 0x4f, 0xdf, 0x30, 0xf1, 0x1b, 0x83, 0xbf, 0xa4, 0xe1, 0x0f,
+	0x82, 0x69, 0xf8, 0x49, 0x18, 0xd9, 0xc5, 0xcd, 0x76, 0x04, 0xae, 0x06, 0xd6, 0x6b, 0x30, 0x21,
+	0xad, 0xd7, 0x69, 0xfd, 0x95, 0x92, 0x5c, 0x82, 0xff, 0xc4, 0xfc, 0x34, 0x04, 0x82, 0xac, 0xb8,
+	0xed, 0xd2, 0x6b, 0xbc, 0x2c, 0xff, 0xad, 0x8f, 0x01, 0x49, 0xc3, 0xad, 0xce, 0x1d, 0xea, 0xb2,
+	0x08, 0x02, 0x41, 0x56, 0xbe, 0x11, 0x15, 0x5f, 0xfe, 0xa3, 0x9b, 0x00, 0xdd, 0x1a, 0x22, 0x73,
+	0x2b, 0xac, 0x2e, 0xda, 0xaa, 0xe0, 0xd8, 0xa2, 0xe0, 0xd8, 0xaa, 0x2a, 0xe9, 0x82, 0x63, 0xdf,
+	0xef, 0x6e, 0x55, 0x39, 0xe6, 0x19, 0x23, 0xf9, 0xc8, 0xd0, 0x1b, 0x1b, 0x81, 0x6b, 0x9e, 0x0b,
+	0x90, 0x6d, 0x52, 0x57, 0x64, 0x97, 0x59, 0x2e, 0xac, 0x9e, 0xb0, 0xbb, 0x05, 0xce, 0xbe, 0x43,
+	0xdd, 0xb2, 0x5c, 0x44, 0x9b, 0x29, 0x74, 0x96, 0x8e, 0xa4, 0xa3, 0x10, 0xe2, 0x7c, 0xac, 0x49,
+	0xbd, 0x03, 0xf7, 0x71, 0x88, 0xfd, 0x68, 0x07, 0xac, 0x4d, 0x4d, 0x2d, 0x9a, 0xd5, 0xd4, 0xae,
+	0xc0, 0x68, 0x4b, 0xce, 0xc8, 0xad, 0x29, 0xac, 0xa2, 0x38, 0x39, 0x65, 0xbb, 0x96, 0x7d, 0xfa,
+	0xbc, 0x34, 0x54, 0xd6, 0x76, 0xd6, 0x37, 0x06, 0x1c, 0xdf, 0xe0, 0x8d, 0x75, 0xdc, 0x6c, 0xc6,
+	0x76, 0x17, 0x87, 0x2e, 0x8b, 0xce, 0x41, 0xfc, 0xa3, 0x29, 0xc8, 0xb9, 0x98, 0x55, 0x6a, 0xb8,
+	0xa5, 0x9f, 0xc4, 0xa8, 0x8b, 0xd9, 0x3a, 0x6e, 0xa1, 0x0f, 0x61, 0xa2, 0x15, 0xd2, 0x16, 0x65,
+	0x24, 0x3c, 0x78, 0x56, 0xe2, 0x49, 0x8c, 0xaf, 0xad, 0xfe, 0xf6, 0xbc, 0x64, 0xbb, 0x1e, 0x6f,
+	0xb4, 0xab, 0x76, 0x8d, 0xfa, 0x8e, 0xae, 0xfd, 0xea, 0x73, 0x99, 0xd5, 0x77, 0x1c, 0xbe, 0xd7,
+	0x22, 0xcc, 0x5e, 0xef, 0xbe, 0xe7, 0xf2, 0x89, 0x28, 0x56, 0xf4, 0x16, 0x67, 0x20, 0x5f, 0x6b,
+	0x60, 0x2f, 0xa8, 0x78, 0xf5, 0xe9, 0xec, 0xbc, 0xb1, 0x9c, 0x29, 0xe7, 0xe4, 0xf8, 0x56, 0xdd,
+	0x5a, 0x82, 0x93, 0x1b, 0x8c, 0x7b, 0x3e, 0xe6, 0x64, 0x13, 0x77, 0xb7, 0x60, 0x02, 0x32, 0x2e,
+	0x56, 0xe4, 0xb3, 0x65, 0xf1, 0x6b, 0xfd, 0x9a, 0x89, 0xce, 0x31, 0xc4, 0x35, 0xb2, 0xd5, 0x89,
+	0xf2, 0xfc, 0x2f, 0x64, 0x7c, 0xe6, 0xea, 0x9d, 0x9a, 0x89, 0xef, 0xd4, 0x5d, 0xe6, 0x6e, 0xf0,
+	0x06, 0x09, 0x49, 0xdb, 0xdf, 0xea, 0x94, 0x85, 0x15, 0xba, 0x0a, 0xe3, 0x5c, 0xb8, 0x57, 0x6a,
+	0x34, 0xd8, 0xf6, 0x5c, 0x99, 0x63, 0x61, 0x75, 0x2a, 0xee, 0x25, 0xc3, 0xaf, 0xcb, 0xe5, 0x72,
+	0x81, 0x77, 0x07, 0xe8, 0x1a, 0x8c, 0xb7, 0x42, 0x52, 0x27, 0x35, 0xc2, 0x18, 0x0d, 0xd9, 0x74,
+	0x56, 0x5e, 0x9c, 0x43, 0x10, 0x13, 0xe6, 0xa2, 0x0e, 0x56, 0x9b, 0xb4, 0xb6, 0x13, 0x55, 0x9c,
+	0x11, 0xb9, 0x0f, 0x05, 0x39, 0xa7, 0xea, 0x0d, 0x9a, 0x03, 0x50, 0x26, 0xf2, 0x59, 0x8c, 0xca,
+	0x67, 0x31, 0x26, 0x67, 0x64, 0xef, 0x58, 0x8f, 0x96, 0x45, 0x93, 0x9b, 0xce, 0x49, 0xea, 0xa6,
+	0xad, 0x3a, 0xa0, 0x1d, 0x75, 0x40, 0x7b, 0x2b, 0xea, 0x80, 0x6b, 0x79, 0x71, 0x45, 0x1e, 0xff,
+	0x58, 0x32, 0x74, 0x10, 0xb1, 0x92, 0x7a, 0xd2, 0xf9, 0x7f, 0xe6, 0xa4, 0xc7, 0x12, 0x27, 0x8d,
+	0x2c, 0x38, 0xa6, 0xe8, 0xfb, 0xb8, 0x53, 0x11, 0x87, 0x0b, 0xb1, 0x1d, 0xb8, 0x8b, 0x3b, 0x9b,
+	0x98, 0xbd, 0x9d, 0xcd, 0x0f, 0x4f, 0x64, 0xca, 0x79, 0xde, 0xa9, 0x78, 0x41, 0x9d, 0x74, 0xac,
+	0x8b, 0xba, 0x8e, 0x1d, 0x9c, 0x79, 0xb7, 0xc8, 0xd4, 0x31, 0xc7, 0xd1, 0xe5, 0x16, 0xff, 0xd6,
+	0xd7, 0x19, 0xdd, 0xeb, 0xa5, 0xf1, 0x9a, 0x88, 0x1a, 0xbb, 0x23, 0xbc, 0x13, 0x3d, 0xf5, 0xc3,
+	0xee, 0x08, 0xef, 0xb0, 0xbf, 0x74, 0x47, 0xfe, 0x3d, 0xe4, 0xa3, 0x0f, 0xd9, 0xba, 0xac, 0x55,
+	0x55, 0xfc, 0x9c, 0x0e, 0x39, 0xd7, 0x53, 0x07, 0x5d, 0x98, 0x91, 0x9b, 0x24, 0xaa, 0xf6, 0xd6,
+	0x9d, 0x83, 0x0e, 0xab, 0xa7, 0x75, 0x88, 0xff, 0x43, 0x5e, 0x14, 0xe6, 0xca, 0x36, 0xd1, 0x5d,
+	0x6e, 0x6d, 0xe6, 0x87, 0xe7, 0xa5, 0x53, 0x2a, 0x43, 0x56, 0xdf, 0xb1, 0x3d, 0xea, 0xf8, 0x98,
+	0x37, 0xec, 0x5b, 0x01, 0x17, 0xdd, 0x57, 0x7a, 0x5b, 0xd7, 0x61, 0x5a, 0x71, 0xa2, 0x3b, 0x24,
+	0xb8, 0x8b, 0x5b, 0x2d, 0x2f, 0x70, 0xa3, 0xdb, 0x33, 0x03, 0x79, 0x2e, 0xa6, 0x45, 0xba, 0xba,
+	0x17, 0xca, 0xf1, 0xad, 0x7a, 0xac, 0xcd, 0xbc, 0xaf, 0x25, 0x5c, 0x32, 0x80, 0xe6, 0xb4, 0x02,
+	0x63, 0xdb, 0xed, 0xa0, 0x22, 0xbd, 0x74, 0xa5, 0x9a, 0x8c, 0xdf, 0xa7, 0x9b, 0xed, 0x40, 0xfa,
+	0x95, 0xf3, 0xdb, 0xfa, 0xaf, 0x1b, 0x79, 0xf5, 0xbb, 0x71, 0x18, 0x91, 0xa1, 0xd1, 0x23, 0x03,
+	0xa0, 0x2b, 0x45, 0x91, 0x15, 0x0f, 0x91, 0xae, 0x72, 0xcd, 0x85, 0x43, 0x6d, 0x14, 0x3d, 0xeb,
+	0xd2, 0xa7, 0xdf, 0xfe, 0xfc, 0xd5, 0xf0, 0x22, 0x3a, 0xe7, 0x04, 0x52, 0x3f, 0x1e, 0x08, 0x76,
+	0xde, 0xa8, 0x68, 0x45, 0xe4, 0x3c, 0xd4, 0xf7, 0x68, 0x1f, 0x7d, 0x69, 0xc0, 0xb1, 0x84, 0xce,
+	0x44, 0xe7, 0xfb, 0x40, 0xd2, 0x84, 0xac, 0xb9, 0x78, 0x94, 0x99, 0xa6, 0xe3, 0x48, 0x3a, 0x17,
+	0xd0, 0x52, 0x0f, 0x1d, 0x35, 0x4a, 0x61, 0xf4, 0xc4, 0x80, 0x89, 0x5e, 0xc1, 0x88, 0x96, 0xfb,
+	0xd0, 0x06, 0x28, 0x54, 0xf3, 0xc2, 0x1f, 0xb0, 0xd4, 0xd4, 0x5e, 0x97, 0xd4, 0x56, 0x90, 0xd3,
+	0x43, 0x6d, 0x37, 0x72, 0xe8, 0xb2, 0x8b, 0x8b, 0xde, 0x7d, 0xf4, 0x11, 0xe4, 0xb4, 0x14, 0x44,
+	0xa5, 0x3e, 0xb8, 0xa4, 0xbe, 0x34, 0xe7, 0x07, 0x1b, 0x68, 0x1a, 0x17, 0x24, 0x8d, 0x05, 0x74,
+	0xb6, 0x87, 0x86, 0xd6, 0x92, 0x2c, 0xb6, 0x37, 0x9f, 0x40, 0x4e, 0x8b, 0xc0, 0x14, 0xe0, 0xa4,
+	0xd6, 0x4c, 0x01, 0xee, 0xd1, 0x8f, 0x96, 0x2d, 0x81, 0x97, 0xd1, 0x62, 0x0f, 0x30, 0x53, 0x76,
+	0x5d, 0x5c, 0xe7, 0xe1, 0x0e, 0xd9, 0xdb, 0x47, 0x3b, 0x90, 0x15, 0xe2, 0x10, 0xcd, 0xf6, 0x45,
+	0x8e, 0x69, 0x4d, 0x73, 0x6e, 0xc0, 0xaa, 0x06, 0x5d, 0x94, 0xa0, 0xf3, 0xa8, 0xd8, 0x03, 0x2a,
+	0xa4, 0x65, 0x3c, 0xd5, 0x06, 0x8c, 0x2a, 0x71, 0x84, 0x8a, 0x7d, 0x01, 0x13, 0xba, 0xcb, 0x2c,
+	0x0d, 0x5c, 0xd7, 0x90, 0x73, 0x12, 0x72, 0x0a, 0x9d, 0xea, 0x81, 0x54, 0x72, 0x0b, 0x79, 0x90,
+	0xd3, 0x6a, 0x0b, 0x99, 0xf1, 0x50, 0x49, 0x09, 0x66, 0x9e, 0x1d, 0xdc, 0x69, 0x22, 0xa0, 0x92,
+	0x04, 0x9a, 0x41, 0x53, 0x29, 0x4f, 0xaf, 0x26, 0xe2, 0x53, 0x28, 0xc4, 0xf4, 0xd1, 0xa1, 0x70,
+	0x89, 0xac, 0x52, 0x44, 0x95, 0xb5, 0x20, 0xc1, 0xe6, 0xd0, 0x99, 0x5e, 0x30, 0x6d, 0x2b, 0x0a,
+	0x36, 0xf2, 0x21, 0xa7, 0xbb, 0x6d, 0xca, 0x85, 0x49, 0x6a, 0xaf, 0x94, 0x0b, 0xd3, 0xd3, 0xa8,
+	0x07, 0xe6, 0xa7, 0x3a, 0x2c, 0xef, 0xa0, 0x3d, 0x80, 0x6e, 0x1f, 0x48, 0x29, 0x69, 0x7d, 0xcd,
+	0x3c, 0xa5, 0xa4, 0xf5, 0x37, 0x12, 0xcb, 0x92, 0xb8, 0xb3, 0xc8, 0x4c, 0xc5, 0x95, 0xdd, 0x48,
+	0x64, 0xaa, 0x9b, 0x47, 0xea, 0x9b, 0x8c, 0x77, 0x9b, 0xd4, 0x37, 0x99, 0xe8, 0x3b, 0x03, 0x33,
+	0x8d, 0x9a, 0x11, 0xfa, 0xc2, 0x80, 0xf1, 0x78, 0x77, 0x40, 0xe7, 0xfa, 0x13, 0xe9, 0xef, 0x3e,
+	0xe6, 0xf9, 0x23, 0xac, 0x8e, 0x28, 0x9a, 0xaa, 0x73, 0xf9, 0xca, 0xda, 0x79, 0x18, 0x35, 0xb2,
+	0xfd, 0xb5, 0x6b, 0x4f, 0x5f, 0x14, 0x8d, 0x67, 0x2f, 0x8a, 0xc6, 0x4f, 0x2f, 0x8a, 0xc6, 0xe3,
+	0x97, 0xc5, 0xa1, 0x67, 0x2f, 0x8b, 0x43, 0xdf, 0xbf, 0x2c, 0x0e, 0x7d, 0xb0, 0x10, 0xd3, 0x07,
+	0xaa, 0x42, 0xaf, 0x8b, 0xee, 0x1e, 0x05, 0xee, 0x88, 0xd0, 0xd5, 0x51, 0xa9, 0x45, 0xfe, 0xf7,
+	0x7b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb3, 0xc8, 0x2d, 0xbe, 0x31, 0x12, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2997,10 +2997,10 @@ func (m *QueryTokenMappingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error
 	_ = i
 	var l int
 	_ = l
-	if len(m.Token) > 0 {
-		i -= len(m.Token)
-		copy(dAtA[i:], m.Token)
-		i = encodeVarintQuery(dAtA, i, uint64(len(m.Token)))
+	if len(m.TokenId) > 0 {
+		i -= len(m.TokenId)
+		copy(dAtA[i:], m.TokenId)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.TokenId)))
 		i--
 		dAtA[i] = 0xa
 	}
@@ -3457,7 +3457,7 @@ func (m *QueryTokenMappingRequest) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = len(m.Token)
+	l = len(m.TokenId)
 	if l > 0 {
 		n += 1 + l + sovQuery(uint64(l))
 	}
@@ -6147,7 +6147,7 @@ func (m *QueryTokenMappingRequest) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field TokenId", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -6175,7 +6175,7 @@ func (m *QueryTokenMappingRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Token = string(dAtA[iNdEx:postIndex])
+			m.TokenId = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/x/evm/query.pb.gw.go b/x/evm/query.pb.gw.go
index f9b679e79..50c7b5c0e 100644
--- a/x/evm/query.pb.gw.go
+++ b/x/evm/query.pb.gw.go
@@ -570,15 +570,15 @@ func request_Query_TokenMapping_0(ctx context.Context, marshaler runtime.Marshal
 		_   = err
 	)
 
-	val, ok = pathParams["token"]
+	val, ok = pathParams["token_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "token")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "token_id")
 	}
 
-	protoReq.Token, err = runtime.String(val)
+	protoReq.TokenId, err = runtime.String(val)
 
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "token", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "token_id", err)
 	}
 
 	msg, err := client.TokenMapping(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
@@ -597,15 +597,15 @@ func local_request_Query_TokenMapping_0(ctx context.Context, marshaler runtime.M
 		_   = err
 	)
 
-	val, ok = pathParams["token"]
+	val, ok = pathParams["token_id"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "token")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "token_id")
 	}
 
-	protoReq.Token, err = runtime.String(val)
+	protoReq.TokenId, err = runtime.String(val)
 
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "token", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "token_id", err)
 	}
 
 	msg, err := server.TokenMapping(ctx, &protoReq)
@@ -1247,7 +1247,7 @@ var (
 
 	pattern_Query_BaseFee_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"nibiru", "evm", "v1", "base_fee"}, "", runtime.AssumeColonVerbOpt(false)))
 
-	pattern_Query_TokenMapping_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"nibiru", "evm", "v1", "token_mapping", "token"}, "", runtime.AssumeColonVerbOpt(false)))
+	pattern_Query_TokenMapping_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"nibiru", "evm", "v1", "token_mapping", "token_id"}, "", runtime.AssumeColonVerbOpt(false)))
 )
 
 var (

From eeb9e0702fe962ba99cabafce22f8ebec127975b Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 13:28:32 -0700
Subject: [PATCH 15/17] fix: allow for querying by cosmos coin or erc20 address

---
 proto/eth/evm/v1/query.proto    |   7 +-
 x/evm/keeper/grpc_query.go      |  28 +++--
 x/evm/keeper/grpc_query_test.go |  36 ++++--
 x/evm/query.pb.go               | 211 ++++++++++++++++----------------
 x/evm/query.pb.gw.go            |  18 +--
 5 files changed, 166 insertions(+), 134 deletions(-)

diff --git a/proto/eth/evm/v1/query.proto b/proto/eth/evm/v1/query.proto
index e0dbff12a..4e735a3c9 100644
--- a/proto/eth/evm/v1/query.proto
+++ b/proto/eth/evm/v1/query.proto
@@ -77,7 +77,7 @@ service Query {
   }
 
   rpc TokenMapping(QueryTokenMappingRequest) returns (QueryTokenMappingResponse) {
-    option (google.api.http).get = "/nibiru/evm/v1/token_mapping/{token_id}";
+    option (google.api.http).get = "/nibiru/evm/v1/token_mapping/{token}";
   }
 }
 
@@ -310,9 +310,8 @@ message QueryTokenMappingRequest {
   option (gogoproto.equal) = false;
   option (gogoproto.goproto_getters) = false;
 
-  // token identifier which is a sha256 sum of the erc20 address concatenated with the cosmos denom
-  // see `NewFunTokenID()` for more details
-  string token_id = 1;
+  // either the 0x contract address of the ERC-20 token or the cosmos denom
+  string token = 1;
 }
 
 message QueryTokenMappingResponse {
diff --git a/x/evm/keeper/grpc_query.go b/x/evm/keeper/grpc_query.go
index 1b572eeb2..2cc0cd4cd 100644
--- a/x/evm/keeper/grpc_query.go
+++ b/x/evm/keeper/grpc_query.go
@@ -746,12 +746,24 @@ func (k Keeper) TokenMapping(
 ) (*evm.QueryTokenMappingResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
-	funToken, err := k.FunTokens.Get(ctx, []byte(req.TokenId))
-	if err != nil {
-		return nil, grpcstatus.Errorf(grpccodes.NotFound, "token mapping not found for %s", req.TokenId)
-	}
-
-	return &evm.QueryTokenMappingResponse{
-		FunToken: &funToken,
-	}, nil
+	// first try lookup by cosmos denom
+	bankDenomIter := k.FunTokens.Indexes.BankDenom.ExactMatch(ctx, req.Token)
+	funTokenMappings := k.FunTokens.Collect(ctx, bankDenomIter)
+	if len(funTokenMappings) > 0 {
+		// assumes that there is only one mapping for a given denom
+		return &evm.QueryTokenMappingResponse{
+			FunToken: &funTokenMappings[0],
+		}, nil
+	}
+
+	erc20AddrIter := k.FunTokens.Indexes.ERC20Addr.ExactMatch(ctx, gethcommon.HexToAddress(req.Token))
+	funTokenMappings = k.FunTokens.Collect(ctx, erc20AddrIter)
+	if len(funTokenMappings) > 0 {
+		// assumes that there is only one mapping for a given erc20 address
+		return &evm.QueryTokenMappingResponse{
+			FunToken: &funTokenMappings[0],
+		}, nil
+	}
+
+	return nil, grpcstatus.Errorf(grpccodes.NotFound, "token mapping not found for %s", req.Token)
 }
diff --git a/x/evm/keeper/grpc_query_test.go b/x/evm/keeper/grpc_query_test.go
index 3dd5e7e51..0539c68bb 100644
--- a/x/evm/keeper/grpc_query_test.go
+++ b/x/evm/keeper/grpc_query_test.go
@@ -903,31 +903,53 @@ func (s *KeeperSuite) TestQueryTokenMapping() {
 			name: "sad: no token mapping",
 			scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) {
 				req = &evm.QueryTokenMappingRequest{
-					TokenId: string(evm.NewFunTokenID(eth.MustNewHexAddrFromStr("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477"), "unibi")),
+					Token: "unibi",
 				}
 				wantResp = &evm.QueryTokenMappingResponse{
 					FunToken: nil,
 				}
 				return req, wantResp
 			},
-			wantErr: "token mapping not found for",
+			wantErr: "token mapping not found for unibi",
 		},
 		{
 			name: "happy: token mapping exists from cosmos coin -> ERC20 token",
 			setup: func(deps *evmtest.TestDeps) {
-				erc20Addr := eth.MustNewHexAddrFromStr("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477")
-				deps.K.FunTokens.Insert(deps.Ctx,
-					evm.NewFunTokenID(erc20Addr, "unibi"),
-					evm.FunToken{
+				deps.K.FunTokens.SafeInsert(
+					deps.Ctx,
+					gethcommon.HexToAddress("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477"),
+					"unibi",
+					true,
+				)
+			},
+			scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) {
+				req = &evm.QueryTokenMappingRequest{
+					Token: "unibi",
+				}
+				wantResp = &evm.QueryTokenMappingResponse{
+					FunToken: &evm.FunToken{
 						Erc20Addr:      "0xAEf9437FF23D48D73271a41a8A094DEc9ac71477",
 						BankDenom:      "unibi",
 						IsMadeFromCoin: true,
 					},
+				}
+				return req, wantResp
+			},
+			wantErr: "",
+		},
+		{
+			name: "happy: token mapping exists from ERC20 token -> cosmos coin",
+			setup: func(deps *evmtest.TestDeps) {
+				deps.K.FunTokens.SafeInsert(
+					deps.Ctx,
+					gethcommon.HexToAddress("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477"),
+					"unibi",
+					true,
 				)
 			},
 			scenario: func(deps *evmtest.TestDeps) (req In, wantResp Out) {
 				req = &evm.QueryTokenMappingRequest{
-					TokenId: string(evm.NewFunTokenID(eth.MustNewHexAddrFromStr("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477"), "unibi")),
+					Token: "0xAEf9437FF23D48D73271a41a8A094DEc9ac71477",
 				}
 				wantResp = &evm.QueryTokenMappingResponse{
 					FunToken: &evm.FunToken{
diff --git a/x/evm/query.pb.go b/x/evm/query.pb.go
index 0ba945207..11e584f99 100644
--- a/x/evm/query.pb.go
+++ b/x/evm/query.pb.go
@@ -1304,9 +1304,8 @@ func (m *QueryBaseFeeResponse) XXX_DiscardUnknown() {
 var xxx_messageInfo_QueryBaseFeeResponse proto.InternalMessageInfo
 
 type QueryTokenMappingRequest struct {
-	// token identifier which is a sha256 sum of the erc20 address concatenated with the cosmos denom
-	// see `NewFunTokenID()` for more details
-	TokenId string `protobuf:"bytes,1,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"`
+	// either the 0x contract address of the ERC-20 token or the cosmos denom
+	Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
 }
 
 func (m *QueryTokenMappingRequest) Reset()         { *m = QueryTokenMappingRequest{} }
@@ -1412,104 +1411,104 @@ func init() {
 func init() { proto.RegisterFile("eth/evm/v1/query.proto", fileDescriptor_ffa36cdc5add14ed) }
 
 var fileDescriptor_ffa36cdc5add14ed = []byte{
-	// 1550 bytes of a gzipped FileDescriptorProto
+	// 1544 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0x4d, 0x6f, 0x1b, 0x55,
 	0x17, 0xce, 0xc4, 0x4e, 0xec, 0x1c, 0xa7, 0x6d, 0xde, 0xdb, 0xb4, 0x49, 0xa6, 0x89, 0x9d, 0x4e,
-	0xda, 0x24, 0xed, 0xdb, 0xce, 0x34, 0x79, 0x5f, 0x81, 0xa8, 0xa8, 0xaa, 0x26, 0x4a, 0x43, 0xe9,
-	0x87, 0x8a, 0x89, 0x10, 0x42, 0x42, 0xd6, 0xb5, 0x7d, 0x33, 0x1e, 0xc5, 0x33, 0xd7, 0x9d, 0x7b,
-	0x1d, 0x1c, 0x4a, 0x36, 0x74, 0x83, 0x04, 0x12, 0x95, 0xf8, 0x03, 0x5d, 0xf1, 0x17, 0xf8, 0x0b,
-	0x5d, 0x56, 0x82, 0x05, 0x62, 0x51, 0x50, 0xcb, 0x82, 0x35, 0x4b, 0x56, 0xe8, 0x7e, 0x4c, 0x3c,
-	0x63, 0x8f, 0x13, 0xca, 0xc7, 0x8e, 0xd5, 0xcc, 0xbd, 0xf7, 0x9c, 0xf3, 0x3c, 0xe7, 0x7e, 0x9c,
-	0xf3, 0xc0, 0x69, 0xc2, 0x1b, 0x0e, 0xd9, 0xf5, 0x9d, 0xdd, 0x15, 0xe7, 0x41, 0x9b, 0x84, 0x7b,
-	0x76, 0x2b, 0xa4, 0x9c, 0x22, 0x20, 0xbc, 0x61, 0x93, 0x5d, 0xdf, 0xde, 0x5d, 0x31, 0x2f, 0xd6,
-	0x28, 0xf3, 0x29, 0x73, 0xaa, 0x98, 0x11, 0x65, 0xe4, 0xec, 0xae, 0x54, 0x09, 0xc7, 0x2b, 0x4e,
-	0x0b, 0xbb, 0x5e, 0x80, 0xb9, 0x47, 0x03, 0xe5, 0x67, 0x4e, 0xc6, 0xe2, 0x09, 0x77, 0x35, 0x7b,
-	0x32, 0x36, 0xcb, 0x3b, 0x91, 0xa9, 0x4b, 0x5d, 0x2a, 0x7f, 0x1d, 0xf1, 0xa7, 0x67, 0x67, 0x5d,
-	0x4a, 0xdd, 0x26, 0x71, 0x70, 0xcb, 0x73, 0x70, 0x10, 0x50, 0x2e, 0xa3, 0x33, 0xbd, 0x5a, 0xd2,
-	0xab, 0x72, 0x54, 0x6d, 0x6f, 0x3b, 0xdc, 0xf3, 0x09, 0xe3, 0xd8, 0x6f, 0x29, 0x03, 0xeb, 0x4d,
-	0x38, 0xfd, 0x8e, 0x60, 0xb8, 0xc1, 0x1b, 0x37, 0x6a, 0x35, 0xda, 0x0e, 0x78, 0x99, 0x3c, 0x68,
-	0x13, 0xc6, 0xd1, 0x34, 0xe4, 0x70, 0xbd, 0x1e, 0x12, 0xc6, 0xa6, 0x8d, 0x79, 0x63, 0x79, 0xac,
-	0x1c, 0x0d, 0xaf, 0xe6, 0x3f, 0x7b, 0x52, 0x1a, 0xfa, 0xe5, 0x49, 0x69, 0xc8, 0xda, 0x86, 0xa9,
-	0x3e, 0x6f, 0xd6, 0xa2, 0x01, 0x23, 0xc2, 0xbd, 0x8a, 0x9b, 0x38, 0xa8, 0x91, 0xc8, 0x5d, 0x0f,
-	0xd1, 0x19, 0x18, 0xab, 0xd1, 0x3a, 0xa9, 0x34, 0x30, 0x6b, 0x4c, 0x0f, 0xcb, 0xb5, 0xbc, 0x98,
-	0x78, 0x0b, 0xb3, 0x06, 0x9a, 0x84, 0x91, 0x80, 0x0a, 0xa7, 0xcc, 0xbc, 0xb1, 0x9c, 0x2d, 0xab,
-	0x81, 0x75, 0x1d, 0x66, 0x24, 0xce, 0x3d, 0xaf, 0xea, 0x85, 0xed, 0x3f, 0x41, 0x74, 0x0f, 0xcc,
-	0xb4, 0x00, 0x5d, 0xae, 0xe9, 0x11, 0x90, 0x09, 0x79, 0x26, 0x60, 0x04, 0xa3, 0x61, 0xc9, 0xe8,
-	0x60, 0x8c, 0xce, 0xc3, 0x71, 0xac, 0x02, 0x55, 0x82, 0xb6, 0x5f, 0x25, 0xa1, 0xe6, 0x7c, 0x4c,
-	0xcf, 0xde, 0x93, 0x93, 0xd6, 0x6d, 0x98, 0x95, 0xd0, 0xef, 0xe1, 0xa6, 0x57, 0xc7, 0x9c, 0x86,
-	0x3d, 0xf4, 0xcf, 0xc2, 0x78, 0x8d, 0x06, 0xac, 0x92, 0x64, 0x50, 0x10, 0x73, 0x37, 0xfa, 0xf2,
-	0xf8, 0xdc, 0x80, 0xb9, 0x01, 0xd1, 0x74, 0x2e, 0x4b, 0x70, 0x22, 0x62, 0x95, 0x8c, 0x18, 0x91,
-	0xbd, 0xf1, 0xf7, 0xa5, 0xf6, 0x06, 0x9c, 0x94, 0x64, 0xd6, 0xd4, 0xc9, 0xbe, 0xca, 0x81, 0x5c,
-	0x81, 0xc9, 0xa4, 0xeb, 0x51, 0xd7, 0xc6, 0xba, 0xad, 0xc1, 0xde, 0xe5, 0x34, 0xc4, 0xee, 0xd1,
-	0x60, 0x68, 0x02, 0x32, 0x3b, 0x64, 0x4f, 0xdf, 0x30, 0xf1, 0x1b, 0x83, 0xbf, 0xa4, 0xe1, 0x0f,
-	0x82, 0x69, 0xf8, 0x49, 0x18, 0xd9, 0xc5, 0xcd, 0x76, 0x04, 0xae, 0x06, 0xd6, 0x6b, 0x30, 0x21,
-	0xad, 0xd7, 0x69, 0xfd, 0x95, 0x92, 0x5c, 0x82, 0xff, 0xc4, 0xfc, 0x34, 0x04, 0x82, 0xac, 0xb8,
-	0xed, 0xd2, 0x6b, 0xbc, 0x2c, 0xff, 0xad, 0x8f, 0x01, 0x49, 0xc3, 0xad, 0xce, 0x1d, 0xea, 0xb2,
-	0x08, 0x02, 0x41, 0x56, 0xbe, 0x11, 0x15, 0x5f, 0xfe, 0xa3, 0x9b, 0x00, 0xdd, 0x1a, 0x22, 0x73,
-	0x2b, 0xac, 0x2e, 0xda, 0xaa, 0xe0, 0xd8, 0xa2, 0xe0, 0xd8, 0xaa, 0x2a, 0xe9, 0x82, 0x63, 0xdf,
-	0xef, 0x6e, 0x55, 0x39, 0xe6, 0x19, 0x23, 0xf9, 0xc8, 0xd0, 0x1b, 0x1b, 0x81, 0x6b, 0x9e, 0x0b,
-	0x90, 0x6d, 0x52, 0x57, 0x64, 0x97, 0x59, 0x2e, 0xac, 0x9e, 0xb0, 0xbb, 0x05, 0xce, 0xbe, 0x43,
-	0xdd, 0xb2, 0x5c, 0x44, 0x9b, 0x29, 0x74, 0x96, 0x8e, 0xa4, 0xa3, 0x10, 0xe2, 0x7c, 0xac, 0x49,
-	0xbd, 0x03, 0xf7, 0x71, 0x88, 0xfd, 0x68, 0x07, 0xac, 0x4d, 0x4d, 0x2d, 0x9a, 0xd5, 0xd4, 0xae,
-	0xc0, 0x68, 0x4b, 0xce, 0xc8, 0xad, 0x29, 0xac, 0xa2, 0x38, 0x39, 0x65, 0xbb, 0x96, 0x7d, 0xfa,
-	0xbc, 0x34, 0x54, 0xd6, 0x76, 0xd6, 0x37, 0x06, 0x1c, 0xdf, 0xe0, 0x8d, 0x75, 0xdc, 0x6c, 0xc6,
-	0x76, 0x17, 0x87, 0x2e, 0x8b, 0xce, 0x41, 0xfc, 0xa3, 0x29, 0xc8, 0xb9, 0x98, 0x55, 0x6a, 0xb8,
-	0xa5, 0x9f, 0xc4, 0xa8, 0x8b, 0xd9, 0x3a, 0x6e, 0xa1, 0x0f, 0x61, 0xa2, 0x15, 0xd2, 0x16, 0x65,
-	0x24, 0x3c, 0x78, 0x56, 0xe2, 0x49, 0x8c, 0xaf, 0xad, 0xfe, 0xf6, 0xbc, 0x64, 0xbb, 0x1e, 0x6f,
-	0xb4, 0xab, 0x76, 0x8d, 0xfa, 0x8e, 0xae, 0xfd, 0xea, 0x73, 0x99, 0xd5, 0x77, 0x1c, 0xbe, 0xd7,
-	0x22, 0xcc, 0x5e, 0xef, 0xbe, 0xe7, 0xf2, 0x89, 0x28, 0x56, 0xf4, 0x16, 0x67, 0x20, 0x5f, 0x6b,
-	0x60, 0x2f, 0xa8, 0x78, 0xf5, 0xe9, 0xec, 0xbc, 0xb1, 0x9c, 0x29, 0xe7, 0xe4, 0xf8, 0x56, 0xdd,
-	0x5a, 0x82, 0x93, 0x1b, 0x8c, 0x7b, 0x3e, 0xe6, 0x64, 0x13, 0x77, 0xb7, 0x60, 0x02, 0x32, 0x2e,
-	0x56, 0xe4, 0xb3, 0x65, 0xf1, 0x6b, 0xfd, 0x9a, 0x89, 0xce, 0x31, 0xc4, 0x35, 0xb2, 0xd5, 0x89,
-	0xf2, 0xfc, 0x2f, 0x64, 0x7c, 0xe6, 0xea, 0x9d, 0x9a, 0x89, 0xef, 0xd4, 0x5d, 0xe6, 0x6e, 0xf0,
-	0x06, 0x09, 0x49, 0xdb, 0xdf, 0xea, 0x94, 0x85, 0x15, 0xba, 0x0a, 0xe3, 0x5c, 0xb8, 0x57, 0x6a,
-	0x34, 0xd8, 0xf6, 0x5c, 0x99, 0x63, 0x61, 0x75, 0x2a, 0xee, 0x25, 0xc3, 0xaf, 0xcb, 0xe5, 0x72,
-	0x81, 0x77, 0x07, 0xe8, 0x1a, 0x8c, 0xb7, 0x42, 0x52, 0x27, 0x35, 0xc2, 0x18, 0x0d, 0xd9, 0x74,
-	0x56, 0x5e, 0x9c, 0x43, 0x10, 0x13, 0xe6, 0xa2, 0x0e, 0x56, 0x9b, 0xb4, 0xb6, 0x13, 0x55, 0x9c,
-	0x11, 0xb9, 0x0f, 0x05, 0x39, 0xa7, 0xea, 0x0d, 0x9a, 0x03, 0x50, 0x26, 0xf2, 0x59, 0x8c, 0xca,
-	0x67, 0x31, 0x26, 0x67, 0x64, 0xef, 0x58, 0x8f, 0x96, 0x45, 0x93, 0x9b, 0xce, 0x49, 0xea, 0xa6,
-	0xad, 0x3a, 0xa0, 0x1d, 0x75, 0x40, 0x7b, 0x2b, 0xea, 0x80, 0x6b, 0x79, 0x71, 0x45, 0x1e, 0xff,
-	0x58, 0x32, 0x74, 0x10, 0xb1, 0x92, 0x7a, 0xd2, 0xf9, 0x7f, 0xe6, 0xa4, 0xc7, 0x12, 0x27, 0x8d,
-	0x2c, 0x38, 0xa6, 0xe8, 0xfb, 0xb8, 0x53, 0x11, 0x87, 0x0b, 0xb1, 0x1d, 0xb8, 0x8b, 0x3b, 0x9b,
-	0x98, 0xbd, 0x9d, 0xcd, 0x0f, 0x4f, 0x64, 0xca, 0x79, 0xde, 0xa9, 0x78, 0x41, 0x9d, 0x74, 0xac,
-	0x8b, 0xba, 0x8e, 0x1d, 0x9c, 0x79, 0xb7, 0xc8, 0xd4, 0x31, 0xc7, 0xd1, 0xe5, 0x16, 0xff, 0xd6,
-	0xd7, 0x19, 0xdd, 0xeb, 0xa5, 0xf1, 0x9a, 0x88, 0x1a, 0xbb, 0x23, 0xbc, 0x13, 0x3d, 0xf5, 0xc3,
-	0xee, 0x08, 0xef, 0xb0, 0xbf, 0x74, 0x47, 0xfe, 0x3d, 0xe4, 0xa3, 0x0f, 0xd9, 0xba, 0xac, 0x55,
-	0x55, 0xfc, 0x9c, 0x0e, 0x39, 0xd7, 0x53, 0x07, 0x5d, 0x98, 0x91, 0x9b, 0x24, 0xaa, 0xf6, 0xd6,
-	0x9d, 0x83, 0x0e, 0xab, 0xa7, 0x75, 0x88, 0xff, 0x43, 0x5e, 0x14, 0xe6, 0xca, 0x36, 0xd1, 0x5d,
-	0x6e, 0x6d, 0xe6, 0x87, 0xe7, 0xa5, 0x53, 0x2a, 0x43, 0x56, 0xdf, 0xb1, 0x3d, 0xea, 0xf8, 0x98,
-	0x37, 0xec, 0x5b, 0x01, 0x17, 0xdd, 0x57, 0x7a, 0x5b, 0xd7, 0x61, 0x5a, 0x71, 0xa2, 0x3b, 0x24,
-	0xb8, 0x8b, 0x5b, 0x2d, 0x2f, 0x70, 0xa3, 0xdb, 0x33, 0x03, 0x79, 0x2e, 0xa6, 0x45, 0xba, 0xba,
-	0x17, 0xca, 0xf1, 0xad, 0x7a, 0xac, 0xcd, 0xbc, 0xaf, 0x25, 0x5c, 0x32, 0x80, 0xe6, 0xb4, 0x02,
-	0x63, 0xdb, 0xed, 0xa0, 0x22, 0xbd, 0x74, 0xa5, 0x9a, 0x8c, 0xdf, 0xa7, 0x9b, 0xed, 0x40, 0xfa,
-	0x95, 0xf3, 0xdb, 0xfa, 0xaf, 0x1b, 0x79, 0xf5, 0xbb, 0x71, 0x18, 0x91, 0xa1, 0xd1, 0x23, 0x03,
-	0xa0, 0x2b, 0x45, 0x91, 0x15, 0x0f, 0x91, 0xae, 0x72, 0xcd, 0x85, 0x43, 0x6d, 0x14, 0x3d, 0xeb,
-	0xd2, 0xa7, 0xdf, 0xfe, 0xfc, 0xd5, 0xf0, 0x22, 0x3a, 0xe7, 0x04, 0x52, 0x3f, 0x1e, 0x08, 0x76,
-	0xde, 0xa8, 0x68, 0x45, 0xe4, 0x3c, 0xd4, 0xf7, 0x68, 0x1f, 0x7d, 0x69, 0xc0, 0xb1, 0x84, 0xce,
-	0x44, 0xe7, 0xfb, 0x40, 0xd2, 0x84, 0xac, 0xb9, 0x78, 0x94, 0x99, 0xa6, 0xe3, 0x48, 0x3a, 0x17,
-	0xd0, 0x52, 0x0f, 0x1d, 0x35, 0x4a, 0x61, 0xf4, 0xc4, 0x80, 0x89, 0x5e, 0xc1, 0x88, 0x96, 0xfb,
-	0xd0, 0x06, 0x28, 0x54, 0xf3, 0xc2, 0x1f, 0xb0, 0xd4, 0xd4, 0x5e, 0x97, 0xd4, 0x56, 0x90, 0xd3,
-	0x43, 0x6d, 0x37, 0x72, 0xe8, 0xb2, 0x8b, 0x8b, 0xde, 0x7d, 0xf4, 0x11, 0xe4, 0xb4, 0x14, 0x44,
-	0xa5, 0x3e, 0xb8, 0xa4, 0xbe, 0x34, 0xe7, 0x07, 0x1b, 0x68, 0x1a, 0x17, 0x24, 0x8d, 0x05, 0x74,
-	0xb6, 0x87, 0x86, 0xd6, 0x92, 0x2c, 0xb6, 0x37, 0x9f, 0x40, 0x4e, 0x8b, 0xc0, 0x14, 0xe0, 0xa4,
-	0xd6, 0x4c, 0x01, 0xee, 0xd1, 0x8f, 0x96, 0x2d, 0x81, 0x97, 0xd1, 0x62, 0x0f, 0x30, 0x53, 0x76,
-	0x5d, 0x5c, 0xe7, 0xe1, 0x0e, 0xd9, 0xdb, 0x47, 0x3b, 0x90, 0x15, 0xe2, 0x10, 0xcd, 0xf6, 0x45,
-	0x8e, 0x69, 0x4d, 0x73, 0x6e, 0xc0, 0xaa, 0x06, 0x5d, 0x94, 0xa0, 0xf3, 0xa8, 0xd8, 0x03, 0x2a,
-	0xa4, 0x65, 0x3c, 0xd5, 0x06, 0x8c, 0x2a, 0x71, 0x84, 0x8a, 0x7d, 0x01, 0x13, 0xba, 0xcb, 0x2c,
-	0x0d, 0x5c, 0xd7, 0x90, 0x73, 0x12, 0x72, 0x0a, 0x9d, 0xea, 0x81, 0x54, 0x72, 0x0b, 0x79, 0x90,
-	0xd3, 0x6a, 0x0b, 0x99, 0xf1, 0x50, 0x49, 0x09, 0x66, 0x9e, 0x1d, 0xdc, 0x69, 0x22, 0xa0, 0x92,
-	0x04, 0x9a, 0x41, 0x53, 0x29, 0x4f, 0xaf, 0x26, 0xe2, 0x53, 0x28, 0xc4, 0xf4, 0xd1, 0xa1, 0x70,
-	0x89, 0xac, 0x52, 0x44, 0x95, 0xb5, 0x20, 0xc1, 0xe6, 0xd0, 0x99, 0x5e, 0x30, 0x6d, 0x2b, 0x0a,
-	0x36, 0xf2, 0x21, 0xa7, 0xbb, 0x6d, 0xca, 0x85, 0x49, 0x6a, 0xaf, 0x94, 0x0b, 0xd3, 0xd3, 0xa8,
-	0x07, 0xe6, 0xa7, 0x3a, 0x2c, 0xef, 0xa0, 0x3d, 0x80, 0x6e, 0x1f, 0x48, 0x29, 0x69, 0x7d, 0xcd,
-	0x3c, 0xa5, 0xa4, 0xf5, 0x37, 0x12, 0xcb, 0x92, 0xb8, 0xb3, 0xc8, 0x4c, 0xc5, 0x95, 0xdd, 0x48,
-	0x64, 0xaa, 0x9b, 0x47, 0xea, 0x9b, 0x8c, 0x77, 0x9b, 0xd4, 0x37, 0x99, 0xe8, 0x3b, 0x03, 0x33,
-	0x8d, 0x9a, 0x11, 0xfa, 0xc2, 0x80, 0xf1, 0x78, 0x77, 0x40, 0xe7, 0xfa, 0x13, 0xe9, 0xef, 0x3e,
-	0xe6, 0xf9, 0x23, 0xac, 0x8e, 0x28, 0x9a, 0xaa, 0x73, 0xf9, 0xca, 0xda, 0x79, 0x18, 0x35, 0xb2,
-	0xfd, 0xb5, 0x6b, 0x4f, 0x5f, 0x14, 0x8d, 0x67, 0x2f, 0x8a, 0xc6, 0x4f, 0x2f, 0x8a, 0xc6, 0xe3,
-	0x97, 0xc5, 0xa1, 0x67, 0x2f, 0x8b, 0x43, 0xdf, 0xbf, 0x2c, 0x0e, 0x7d, 0xb0, 0x10, 0xd3, 0x07,
-	0xaa, 0x42, 0xaf, 0x8b, 0xee, 0x1e, 0x05, 0xee, 0x88, 0xd0, 0xd5, 0x51, 0xa9, 0x45, 0xfe, 0xf7,
-	0x7b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb3, 0xc8, 0x2d, 0xbe, 0x31, 0x12, 0x00, 0x00,
+	0xda, 0x24, 0xed, 0xdb, 0xce, 0x34, 0x01, 0x81, 0xa8, 0xa8, 0x50, 0x13, 0xa5, 0xa1, 0xf4, 0x43,
+	0xc5, 0x44, 0x08, 0x21, 0x21, 0xeb, 0xda, 0xbe, 0x19, 0x8f, 0xe2, 0x99, 0xeb, 0xce, 0xbd, 0x0e,
+	0x0e, 0x25, 0x1b, 0xba, 0x01, 0xb1, 0xa0, 0x12, 0x7f, 0xa0, 0x2b, 0xfe, 0x02, 0x7f, 0xa1, 0xcb,
+	0x22, 0x36, 0x88, 0x45, 0x41, 0x2d, 0x0b, 0xd6, 0x2c, 0x59, 0xa1, 0xfb, 0x31, 0xf1, 0x8c, 0x3d,
+	0x4e, 0x28, 0x1f, 0x3b, 0x56, 0x33, 0xf7, 0xde, 0x73, 0xce, 0xf3, 0x9c, 0xfb, 0x71, 0xce, 0x03,
+	0xa7, 0x09, 0x6f, 0x38, 0x64, 0xd7, 0x77, 0x76, 0x57, 0x9c, 0xfb, 0x6d, 0x12, 0xee, 0xd9, 0xad,
+	0x90, 0x72, 0x8a, 0x80, 0xf0, 0x86, 0x4d, 0x76, 0x7d, 0x7b, 0x77, 0xc5, 0xbc, 0x58, 0xa3, 0xcc,
+	0xa7, 0xcc, 0xa9, 0x62, 0x46, 0x94, 0x91, 0xb3, 0xbb, 0x52, 0x25, 0x1c, 0xaf, 0x38, 0x2d, 0xec,
+	0x7a, 0x01, 0xe6, 0x1e, 0x0d, 0x94, 0x9f, 0x39, 0x19, 0x8b, 0x27, 0xdc, 0xd5, 0xec, 0xc9, 0xd8,
+	0x2c, 0xef, 0x44, 0xa6, 0x2e, 0x75, 0xa9, 0xfc, 0x75, 0xc4, 0x9f, 0x9e, 0x9d, 0x75, 0x29, 0x75,
+	0x9b, 0xc4, 0xc1, 0x2d, 0xcf, 0xc1, 0x41, 0x40, 0xb9, 0x8c, 0xce, 0xf4, 0x6a, 0x49, 0xaf, 0xca,
+	0x51, 0xb5, 0xbd, 0xed, 0x70, 0xcf, 0x27, 0x8c, 0x63, 0xbf, 0xa5, 0x0c, 0xac, 0x37, 0xe1, 0xf4,
+	0xbb, 0x82, 0xe1, 0x06, 0x6f, 0x5c, 0xaf, 0xd5, 0x68, 0x3b, 0xe0, 0x65, 0x72, 0xbf, 0x4d, 0x18,
+	0x47, 0xd3, 0x90, 0xc3, 0xf5, 0x7a, 0x48, 0x18, 0x9b, 0x36, 0xe6, 0x8d, 0xe5, 0xb1, 0x72, 0x34,
+	0xbc, 0x9a, 0xff, 0xfc, 0x71, 0x69, 0xe8, 0xd7, 0xc7, 0xa5, 0x21, 0x6b, 0x1b, 0xa6, 0xfa, 0xbc,
+	0x59, 0x8b, 0x06, 0x8c, 0x08, 0xf7, 0x2a, 0x6e, 0xe2, 0xa0, 0x46, 0x22, 0x77, 0x3d, 0x44, 0x67,
+	0x60, 0xac, 0x46, 0xeb, 0xa4, 0xd2, 0xc0, 0xac, 0x31, 0x3d, 0x2c, 0xd7, 0xf2, 0x62, 0xe2, 0x6d,
+	0xcc, 0x1a, 0x68, 0x12, 0x46, 0x02, 0x2a, 0x9c, 0x32, 0xf3, 0xc6, 0x72, 0xb6, 0xac, 0x06, 0xd6,
+	0x5b, 0x30, 0x23, 0x71, 0xee, 0x7a, 0x55, 0x2f, 0x6c, 0xff, 0x05, 0xa2, 0x7b, 0x60, 0xa6, 0x05,
+	0xe8, 0x72, 0x4d, 0x8f, 0x80, 0x4c, 0xc8, 0x33, 0x01, 0x23, 0x18, 0x0d, 0x4b, 0x46, 0x07, 0x63,
+	0x74, 0x1e, 0x8e, 0x63, 0x15, 0xa8, 0x12, 0xb4, 0xfd, 0x2a, 0x09, 0x35, 0xe7, 0x63, 0x7a, 0xf6,
+	0xae, 0x9c, 0xb4, 0x6e, 0xc1, 0xac, 0x84, 0x7e, 0x1f, 0x37, 0xbd, 0x3a, 0xe6, 0x34, 0xec, 0xa1,
+	0x7f, 0x16, 0xc6, 0x6b, 0x34, 0x60, 0x95, 0x24, 0x83, 0x82, 0x98, 0xbb, 0xde, 0x97, 0xc7, 0x97,
+	0x06, 0xcc, 0x0d, 0x88, 0xa6, 0x73, 0x59, 0x82, 0x13, 0x11, 0xab, 0x64, 0xc4, 0x88, 0xec, 0xf5,
+	0x7f, 0x2e, 0xb5, 0x37, 0xe0, 0xa4, 0x24, 0xb3, 0xa6, 0x4e, 0xf6, 0x65, 0x0e, 0xe4, 0x0a, 0x4c,
+	0x26, 0x5d, 0x8f, 0xba, 0x36, 0xd6, 0x2d, 0x0d, 0xf6, 0x1e, 0xa7, 0x21, 0x76, 0x8f, 0x06, 0x43,
+	0x13, 0x90, 0xd9, 0x21, 0x7b, 0xfa, 0x86, 0x89, 0xdf, 0x18, 0xfc, 0x25, 0x0d, 0x7f, 0x10, 0x4c,
+	0xc3, 0x4f, 0xc2, 0xc8, 0x2e, 0x6e, 0xb6, 0x23, 0x70, 0x35, 0xb0, 0x5e, 0x83, 0x09, 0x69, 0xbd,
+	0x4e, 0xeb, 0x2f, 0x95, 0xe4, 0x12, 0xfc, 0x2f, 0xe6, 0xa7, 0x21, 0x10, 0x64, 0xc5, 0x6d, 0x97,
+	0x5e, 0xe3, 0x65, 0xf9, 0x6f, 0x7d, 0x02, 0x48, 0x1a, 0x6e, 0x75, 0x6e, 0x53, 0x97, 0x45, 0x10,
+	0x08, 0xb2, 0xf2, 0x8d, 0xa8, 0xf8, 0xf2, 0x1f, 0xdd, 0x00, 0xe8, 0xd6, 0x10, 0x99, 0x5b, 0x61,
+	0x75, 0xd1, 0x56, 0x05, 0xc7, 0x16, 0x05, 0xc7, 0x56, 0x55, 0x49, 0x17, 0x1c, 0xfb, 0x5e, 0x77,
+	0xab, 0xca, 0x31, 0xcf, 0x18, 0xc9, 0x87, 0x86, 0xde, 0xd8, 0x08, 0x5c, 0xf3, 0x5c, 0x80, 0x6c,
+	0x93, 0xba, 0x22, 0xbb, 0xcc, 0x72, 0x61, 0xf5, 0x84, 0xdd, 0x2d, 0x70, 0xf6, 0x6d, 0xea, 0x96,
+	0xe5, 0x22, 0xda, 0x4c, 0xa1, 0xb3, 0x74, 0x24, 0x1d, 0x85, 0x10, 0xe7, 0x63, 0x4d, 0xea, 0x1d,
+	0xb8, 0x87, 0x43, 0xec, 0x47, 0x3b, 0x60, 0x6d, 0x6a, 0x6a, 0xd1, 0xac, 0xa6, 0x76, 0x05, 0x46,
+	0x5b, 0x72, 0x46, 0x6e, 0x4d, 0x61, 0x15, 0xc5, 0xc9, 0x29, 0xdb, 0xb5, 0xec, 0x93, 0x67, 0xa5,
+	0xa1, 0xb2, 0xb6, 0xb3, 0xbe, 0x35, 0xe0, 0xf8, 0x06, 0x6f, 0xac, 0xe3, 0x66, 0x33, 0xb6, 0xbb,
+	0x38, 0x74, 0x59, 0x74, 0x0e, 0xe2, 0x1f, 0x4d, 0x41, 0xce, 0xc5, 0xac, 0x52, 0xc3, 0x2d, 0xfd,
+	0x24, 0x46, 0x5d, 0xcc, 0xd6, 0x71, 0x0b, 0x7d, 0x04, 0x13, 0xad, 0x90, 0xb6, 0x28, 0x23, 0xe1,
+	0xc1, 0xb3, 0x12, 0x4f, 0x62, 0x7c, 0x6d, 0xf5, 0xf7, 0x67, 0x25, 0xdb, 0xf5, 0x78, 0xa3, 0x5d,
+	0xb5, 0x6b, 0xd4, 0x77, 0x74, 0xed, 0x57, 0x9f, 0xcb, 0xac, 0xbe, 0xe3, 0xf0, 0xbd, 0x16, 0x61,
+	0xf6, 0x7a, 0xf7, 0x3d, 0x97, 0x4f, 0x44, 0xb1, 0xa2, 0xb7, 0x38, 0x03, 0xf9, 0x5a, 0x03, 0x7b,
+	0x41, 0xc5, 0xab, 0x4f, 0x67, 0xe7, 0x8d, 0xe5, 0x4c, 0x39, 0x27, 0xc7, 0x37, 0xeb, 0xd6, 0x12,
+	0x9c, 0xdc, 0x60, 0xdc, 0xf3, 0x31, 0x27, 0x9b, 0xb8, 0xbb, 0x05, 0x13, 0x90, 0x71, 0xb1, 0x22,
+	0x9f, 0x2d, 0x8b, 0x5f, 0xeb, 0xb7, 0x4c, 0x74, 0x8e, 0x21, 0xae, 0x91, 0xad, 0x4e, 0x94, 0xe7,
+	0xff, 0x21, 0xe3, 0x33, 0x57, 0xef, 0xd4, 0x4c, 0x7c, 0xa7, 0xee, 0x30, 0x77, 0x83, 0x37, 0x48,
+	0x48, 0xda, 0xfe, 0x56, 0xa7, 0x2c, 0xac, 0xd0, 0x55, 0x18, 0xe7, 0xc2, 0xbd, 0x52, 0xa3, 0xc1,
+	0xb6, 0xe7, 0xca, 0x1c, 0x0b, 0xab, 0x53, 0x71, 0x2f, 0x19, 0x7e, 0x5d, 0x2e, 0x97, 0x0b, 0xbc,
+	0x3b, 0x40, 0xd7, 0x60, 0xbc, 0x15, 0x92, 0x3a, 0xa9, 0x11, 0xc6, 0x68, 0xc8, 0xa6, 0xb3, 0xf2,
+	0xe2, 0x1c, 0x82, 0x98, 0x30, 0x17, 0x75, 0xb0, 0xda, 0xa4, 0xb5, 0x9d, 0xa8, 0xe2, 0x8c, 0xc8,
+	0x7d, 0x28, 0xc8, 0x39, 0x55, 0x6f, 0xd0, 0x1c, 0x80, 0x32, 0x91, 0xcf, 0x62, 0x54, 0x3e, 0x8b,
+	0x31, 0x39, 0x23, 0x7b, 0xc7, 0x7a, 0xb4, 0x2c, 0x9a, 0xdc, 0x74, 0x4e, 0x52, 0x37, 0x6d, 0xd5,
+	0x01, 0xed, 0xa8, 0x03, 0xda, 0x5b, 0x51, 0x07, 0x5c, 0xcb, 0x8b, 0x2b, 0xf2, 0xe8, 0xa7, 0x92,
+	0xa1, 0x83, 0x88, 0x95, 0xd4, 0x93, 0xce, 0xff, 0x3b, 0x27, 0x3d, 0x96, 0x38, 0x69, 0x64, 0xc1,
+	0x31, 0x45, 0xdf, 0xc7, 0x9d, 0x8a, 0x38, 0x5c, 0x88, 0xed, 0xc0, 0x1d, 0xdc, 0xd9, 0xc4, 0xec,
+	0x9d, 0x6c, 0x7e, 0x78, 0x22, 0x53, 0xce, 0xf3, 0x4e, 0xc5, 0x0b, 0xea, 0xa4, 0x63, 0x5d, 0xd4,
+	0x75, 0xec, 0xe0, 0xcc, 0xbb, 0x45, 0xa6, 0x8e, 0x39, 0x8e, 0x2e, 0xb7, 0xf8, 0xb7, 0xbe, 0xc9,
+	0xe8, 0x5e, 0x2f, 0x8d, 0xd7, 0x44, 0xd4, 0xd8, 0x1d, 0xe1, 0x9d, 0xe8, 0xa9, 0x1f, 0x76, 0x47,
+	0x78, 0x87, 0xfd, 0xad, 0x3b, 0xf2, 0xdf, 0x21, 0x1f, 0x7d, 0xc8, 0xd6, 0x65, 0xad, 0xaa, 0xe2,
+	0xe7, 0x74, 0xc8, 0xb9, 0x9e, 0x3a, 0xe8, 0xc2, 0x8c, 0xdc, 0x20, 0x51, 0xb5, 0xb7, 0x6e, 0x1f,
+	0x74, 0x58, 0x3d, 0xad, 0x43, 0xbc, 0x0a, 0x79, 0x51, 0x98, 0x2b, 0xdb, 0x44, 0x77, 0xb9, 0xb5,
+	0x99, 0x1f, 0x9f, 0x95, 0x4e, 0xa9, 0x0c, 0x59, 0x7d, 0xc7, 0xf6, 0xa8, 0xe3, 0x63, 0xde, 0xb0,
+	0x6f, 0x06, 0x5c, 0x74, 0x5f, 0xe9, 0x6d, 0x5d, 0x85, 0x69, 0xc5, 0x89, 0xee, 0x90, 0xe0, 0x0e,
+	0x6e, 0xb5, 0xbc, 0xc0, 0x8d, 0x6e, 0xcf, 0x24, 0x8c, 0x70, 0x31, 0x1d, 0x35, 0x4d, 0x39, 0x88,
+	0x75, 0x98, 0x0f, 0xb4, 0x7a, 0x4b, 0xfa, 0x6a, 0x3a, 0x2b, 0x30, 0xb6, 0xdd, 0x0e, 0x2a, 0xdd,
+	0x00, 0x85, 0xd5, 0xc9, 0xf8, 0x55, 0xba, 0xd1, 0x0e, 0xa4, 0x5f, 0x39, 0xbf, 0xad, 0xff, 0xba,
+	0x91, 0x57, 0xbf, 0x1b, 0x87, 0x11, 0x19, 0x1a, 0x3d, 0x34, 0x00, 0xba, 0x2a, 0x14, 0x59, 0xf1,
+	0x10, 0xe9, 0x02, 0xd7, 0x5c, 0x38, 0xd4, 0x46, 0xd1, 0xb3, 0x2e, 0x7d, 0xf6, 0xfd, 0x2f, 0x5f,
+	0x0f, 0x2f, 0xa2, 0x73, 0x4e, 0x20, 0xa5, 0xe3, 0x81, 0x56, 0xe7, 0x8d, 0x8a, 0x16, 0x43, 0xce,
+	0x03, 0x7d, 0x85, 0xf6, 0xd1, 0x57, 0x06, 0x1c, 0x4b, 0x48, 0x4c, 0x74, 0xbe, 0x0f, 0x24, 0x4d,
+	0xc3, 0x9a, 0x8b, 0x47, 0x99, 0x69, 0x3a, 0x8e, 0xa4, 0x73, 0x01, 0x2d, 0xf5, 0xd0, 0x51, 0xa3,
+	0x14, 0x46, 0x8f, 0x0d, 0x98, 0xe8, 0xd5, 0x8a, 0x68, 0xb9, 0x0f, 0x6d, 0x80, 0x38, 0x35, 0x2f,
+	0xfc, 0x09, 0x4b, 0x4d, 0xed, 0x75, 0x49, 0x6d, 0x05, 0x39, 0x3d, 0xd4, 0x76, 0x23, 0x87, 0x2e,
+	0xbb, 0xb8, 0xde, 0xdd, 0x47, 0x1f, 0x43, 0x4e, 0xab, 0x40, 0x54, 0xea, 0x83, 0x4b, 0x4a, 0x4b,
+	0x73, 0x7e, 0xb0, 0x81, 0xa6, 0x71, 0x41, 0xd2, 0x58, 0x40, 0x67, 0x7b, 0x68, 0x68, 0x19, 0xc9,
+	0x62, 0x7b, 0xf3, 0x29, 0xe4, 0xb4, 0xfe, 0x4b, 0x01, 0x4e, 0xca, 0xcc, 0x14, 0xe0, 0x1e, 0xe9,
+	0x68, 0xd9, 0x12, 0x78, 0x19, 0x2d, 0xf6, 0x00, 0x33, 0x65, 0xd7, 0xc5, 0x75, 0x1e, 0xec, 0x90,
+	0xbd, 0x7d, 0xb4, 0x03, 0x59, 0xa1, 0x0b, 0xd1, 0x6c, 0x5f, 0xe4, 0x98, 0xcc, 0x34, 0xe7, 0x06,
+	0xac, 0x6a, 0xd0, 0x45, 0x09, 0x3a, 0x8f, 0x8a, 0x3d, 0xa0, 0x42, 0x55, 0xc6, 0x53, 0x6d, 0xc0,
+	0xa8, 0xd2, 0x45, 0xa8, 0xd8, 0x17, 0x30, 0x21, 0xb9, 0xcc, 0xd2, 0xc0, 0x75, 0x0d, 0x39, 0x27,
+	0x21, 0xa7, 0xd0, 0xa9, 0x1e, 0x48, 0xa5, 0xb4, 0x90, 0x07, 0x39, 0x2d, 0xb4, 0x90, 0x19, 0x0f,
+	0x95, 0x54, 0x5f, 0xe6, 0xd9, 0xc1, 0x4d, 0x26, 0x02, 0x2a, 0x49, 0xa0, 0x19, 0x34, 0x95, 0xf2,
+	0xf4, 0x6a, 0x22, 0x3e, 0x85, 0x42, 0x4c, 0x1a, 0x1d, 0x0a, 0x97, 0xc8, 0x2a, 0x45, 0x4f, 0x59,
+	0x0b, 0x12, 0x6c, 0x0e, 0x9d, 0xe9, 0x05, 0xd3, 0xb6, 0xa2, 0x56, 0x23, 0x1f, 0x72, 0xba, 0xd1,
+	0xa6, 0x5c, 0x98, 0xa4, 0xec, 0x4a, 0xb9, 0x30, 0x3d, 0x3d, 0x7a, 0x60, 0x7e, 0xaa, 0xb9, 0xf2,
+	0x0e, 0xda, 0x03, 0xe8, 0xb6, 0x80, 0x94, 0x92, 0xd6, 0xd7, 0xc7, 0x53, 0x4a, 0x5a, 0x7f, 0x0f,
+	0xb1, 0x2c, 0x89, 0x3b, 0x8b, 0xcc, 0x54, 0x5c, 0xd9, 0x88, 0x44, 0xa6, 0xba, 0x6f, 0xa4, 0xbe,
+	0xc9, 0x78, 0xa3, 0x49, 0x7d, 0x93, 0x89, 0x96, 0x33, 0x30, 0xd3, 0xa8, 0x0f, 0xa1, 0x2f, 0x0c,
+	0x18, 0x8f, 0x77, 0x07, 0x74, 0xae, 0x3f, 0x91, 0xfe, 0xc6, 0x63, 0x9e, 0x3f, 0xc2, 0xea, 0x88,
+	0x1a, 0x2e, 0x7b, 0x4e, 0xc5, 0x57, 0xd6, 0xce, 0x03, 0x39, 0xdc, 0x5f, 0xbb, 0xf6, 0xe4, 0x79,
+	0xd1, 0x78, 0xfa, 0xbc, 0x68, 0xfc, 0xfc, 0xbc, 0x68, 0x3c, 0x7a, 0x51, 0x1c, 0x7a, 0xfa, 0xa2,
+	0x38, 0xf4, 0xc3, 0x8b, 0xe2, 0xd0, 0x87, 0x0b, 0x31, 0x5d, 0xa0, 0xca, 0xf3, 0xba, 0xe8, 0xea,
+	0x51, 0xd4, 0x8e, 0x88, 0x5b, 0x1d, 0x95, 0x1a, 0xe4, 0x95, 0x3f, 0x02, 0x00, 0x00, 0xff, 0xff,
+	0xf0, 0xb1, 0xd3, 0x70, 0x29, 0x12, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2997,10 +2996,10 @@ func (m *QueryTokenMappingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error
 	_ = i
 	var l int
 	_ = l
-	if len(m.TokenId) > 0 {
-		i -= len(m.TokenId)
-		copy(dAtA[i:], m.TokenId)
-		i = encodeVarintQuery(dAtA, i, uint64(len(m.TokenId)))
+	if len(m.Token) > 0 {
+		i -= len(m.Token)
+		copy(dAtA[i:], m.Token)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Token)))
 		i--
 		dAtA[i] = 0xa
 	}
@@ -3457,7 +3456,7 @@ func (m *QueryTokenMappingRequest) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = len(m.TokenId)
+	l = len(m.Token)
 	if l > 0 {
 		n += 1 + l + sovQuery(uint64(l))
 	}
@@ -6147,7 +6146,7 @@ func (m *QueryTokenMappingRequest) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TokenId", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -6175,7 +6174,7 @@ func (m *QueryTokenMappingRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.TokenId = string(dAtA[iNdEx:postIndex])
+			m.Token = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/x/evm/query.pb.gw.go b/x/evm/query.pb.gw.go
index 50c7b5c0e..f9b679e79 100644
--- a/x/evm/query.pb.gw.go
+++ b/x/evm/query.pb.gw.go
@@ -570,15 +570,15 @@ func request_Query_TokenMapping_0(ctx context.Context, marshaler runtime.Marshal
 		_   = err
 	)
 
-	val, ok = pathParams["token_id"]
+	val, ok = pathParams["token"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "token_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "token")
 	}
 
-	protoReq.TokenId, err = runtime.String(val)
+	protoReq.Token, err = runtime.String(val)
 
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "token_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "token", err)
 	}
 
 	msg, err := client.TokenMapping(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
@@ -597,15 +597,15 @@ func local_request_Query_TokenMapping_0(ctx context.Context, marshaler runtime.M
 		_   = err
 	)
 
-	val, ok = pathParams["token_id"]
+	val, ok = pathParams["token"]
 	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "token_id")
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "token")
 	}
 
-	protoReq.TokenId, err = runtime.String(val)
+	protoReq.Token, err = runtime.String(val)
 
 	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "token_id", err)
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "token", err)
 	}
 
 	msg, err := server.TokenMapping(ctx, &protoReq)
@@ -1247,7 +1247,7 @@ var (
 
 	pattern_Query_BaseFee_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"nibiru", "evm", "v1", "base_fee"}, "", runtime.AssumeColonVerbOpt(false)))
 
-	pattern_Query_TokenMapping_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"nibiru", "evm", "v1", "token_mapping", "token_id"}, "", runtime.AssumeColonVerbOpt(false)))
+	pattern_Query_TokenMapping_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"nibiru", "evm", "v1", "token_mapping", "token"}, "", runtime.AssumeColonVerbOpt(false)))
 )
 
 var (

From 269b956bc46e77e89ec765352ea6cf35c9456df5 Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 13:30:33 -0700
Subject: [PATCH 16/17] Update CHANGELOG.md

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1903de5ff..8b8ac1825 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -78,6 +78,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - [#1922](https://github.com/NibiruChain/nibiru/pull/1922) - feat(evm): tracer option is read from the config.
 - [#1936](https://github.com/NibiruChain/nibiru/pull/1936) - feat(evm): EVM fungible token protobufs and encoding tests
 - [#1947](https://github.com/NibiruChain/nibiru/pull/1947) - fix(evm): fix FunToken state marshalling
+- [#1949](https://github.com/NibiruChain/nibiru/pull/1949) - feat(evm): add fungible token mapping queries
 
 #### Dapp modules: perp, spot, oracle, etc
 

From 0d429749e48dce5136ba9aecefe1f67aa9aaa401 Mon Sep 17 00:00:00 2001
From: Kevin Yang <5478483+k-yang@users.noreply.github.com>
Date: Fri, 28 Jun 2024 13:45:27 -0700
Subject: [PATCH 17/17] satisfy linter

---
 x/evm/keeper/grpc_query_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/x/evm/keeper/grpc_query_test.go b/x/evm/keeper/grpc_query_test.go
index 0539c68bb..362821fde 100644
--- a/x/evm/keeper/grpc_query_test.go
+++ b/x/evm/keeper/grpc_query_test.go
@@ -915,7 +915,7 @@ func (s *KeeperSuite) TestQueryTokenMapping() {
 		{
 			name: "happy: token mapping exists from cosmos coin -> ERC20 token",
 			setup: func(deps *evmtest.TestDeps) {
-				deps.K.FunTokens.SafeInsert(
+				_ = deps.K.FunTokens.SafeInsert(
 					deps.Ctx,
 					gethcommon.HexToAddress("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477"),
 					"unibi",
@@ -940,7 +940,7 @@ func (s *KeeperSuite) TestQueryTokenMapping() {
 		{
 			name: "happy: token mapping exists from ERC20 token -> cosmos coin",
 			setup: func(deps *evmtest.TestDeps) {
-				deps.K.FunTokens.SafeInsert(
+				_ = deps.K.FunTokens.SafeInsert(
 					deps.Ctx,
 					gethcommon.HexToAddress("0xAEf9437FF23D48D73271a41a8A094DEc9ac71477"),
 					"unibi",