From 34c9ba8a7642ead706e3441f9e1307b3282f6454 Mon Sep 17 00:00:00 2001 From: HolaVencH Date: Tue, 23 Jan 2024 13:41:11 +1300 Subject: [PATCH] update accountmeta test --- go.mod | 11 +- go.sum | 6 - go.work.sum | 1 + xumm-go-client | 1 + xumm/jwt/jwt.go | 2 +- xumm/jwt/jwt_ping.go | 4 +- .../meta/get_account_meta_integration_test.go | 24 ++ xumm/meta/get_account_meta_test.go | 91 +++++++ .../get_curated_assets_integration_test.go | 22 +- xumm/meta/get_hookhash.go | 25 +- xumm/meta/get_hookhash_integration_test.go | 30 +++ xumm/meta/get_hookhash_test.go | 108 ++++++++ xumm/meta/get_hookhashes.go | 33 +++ xumm/meta/get_hookhashes_integration_test.go | 33 +++ xumm/meta/get_hookhashes_test.go | 208 ++++++++++++++ xumm/meta/get_rails_integration_test.go | 29 ++ xumm/meta/get_rails_test.go | 255 ++++++++++++++++++ xumm/meta/meta.go | 3 +- xumm/meta/ping_integration_test.go | 7 +- .../static-test-data/account_meta_result.go | 39 +++ xumm/meta/static-test-data/rails_result.go | 198 ++++++++++++++ xumm/models/account_meta.go | 14 +- xumm/models/application.go | 14 + xumm/models/curated_assets_response.go | 14 +- xumm/models/hookhash_response.go | 4 +- xumm/models/hookhashes_response.go | 3 + xumm/models/jwt_pong.go | 18 ++ ...account_status.go => kyc_info_response.go} | 0 ...state_request.go => kyc_status_request.go} | 0 ...ate_response.go => kyc_status_response.go} | 0 xumm/models/nftoken_detail.go | 9 + xumm/models/pong.go | 6 - xumm/models/rails_response.go | 192 +++++++++++-- xumm/models/rates_currency_reponse.go | 2 +- xumm/models/user_token_validity.go | 4 +- xumm/payload/delete_payload_test.go | 3 - xumm/payload/get_payload_custom_id_test.go | 6 +- xumm/payload/get_payload_uuid_test.go | 6 +- xumm/payload/subscribe_payload_test.go | 10 +- 39 files changed, 1358 insertions(+), 77 deletions(-) create mode 100644 go.work.sum create mode 160000 xumm-go-client create mode 100644 xumm/meta/get_account_meta_integration_test.go create mode 100644 xumm/meta/get_account_meta_test.go create mode 100644 xumm/meta/get_hookhash_integration_test.go create mode 100644 xumm/meta/get_hookhash_test.go create mode 100644 xumm/meta/get_hookhashes.go create mode 100644 xumm/meta/get_hookhashes_integration_test.go create mode 100644 xumm/meta/get_hookhashes_test.go create mode 100644 xumm/meta/get_rails_integration_test.go create mode 100644 xumm/meta/get_rails_test.go create mode 100644 xumm/meta/static-test-data/account_meta_result.go create mode 100644 xumm/meta/static-test-data/rails_result.go create mode 100644 xumm/models/hookhashes_response.go create mode 100644 xumm/models/jwt_pong.go rename xumm/models/{kyc_account_status.go => kyc_info_response.go} (100%) rename xumm/models/{kyc_status_state_request.go => kyc_status_request.go} (100%) rename xumm/models/{kyc_status_state_response.go => kyc_status_response.go} (100%) create mode 100644 xumm/models/nftoken_detail.go diff --git a/go.mod b/go.mod index 78db02e..1b355c9 100644 --- a/go.mod +++ b/go.mod @@ -1,12 +1,19 @@ module github.com/xyield/xumm-go-client -go 1.16 +go 1.18 require ( github.com/gorilla/websocket v1.4.2 github.com/json-iterator/go v1.1.12 - github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/stretchr/testify v1.7.0 github.com/ugorji/go/codec v1.2.7 github.com/xyield/xumm-user-device v0.0.0-20220315190815-aed3ae39e4ab ) + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect +) diff --git a/go.sum b/go.sum index 1b2d83f..1cd3c21 100644 --- a/go.sum +++ b/go.sum @@ -4,13 +4,11 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= @@ -19,13 +17,9 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/ugorji/go v1.2.6/go.mod h1:anCg0y61KIhDlPZmnH+so+RQbysYVyDko0IMgJv0Nn0= -github.com/ugorji/go v1.2.7 h1:qYhyWUUd6WbiM+C6JZAUkIJt/1WrjzNHY9+KCIjVqTo= github.com/ugorji/go v1.2.7/go.mod h1:nF9osbDWLy6bDVv/Rtoh6QgnvNDpmCalQV5urGCCS6M= -github.com/ugorji/go/codec v1.2.6/go.mod h1:V6TCNZ4PHqoHGFZuSG1W8nrCzzdgA2DozYxWFFpvxTw= github.com/ugorji/go/codec v1.2.7 h1:YPXUKf7fYbp/y8xloBqZOw2qaVggbfwMlI8WM3wZUJ0= github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY= -github.com/xyield/xumm-go-client v0.0.0-20220310192812-590915fe9937/go.mod h1:0LoPhdN9OpjWZJaZ86y1sz/oc57PbuAIB5ORwSX5kyc= github.com/xyield/xumm-user-device v0.0.0-20220315190815-aed3ae39e4ab h1:8tFBu+hvANduwkQutWsFDWVR60bXdZ1uoyA7nJgG6FE= github.com/xyield/xumm-user-device v0.0.0-20220315190815-aed3ae39e4ab/go.mod h1:VwNyuWpcqbDmKq6IvvXTDJAFf+skL6M9/pDgQYNyYRk= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= diff --git a/go.work.sum b/go.work.sum new file mode 100644 index 0000000..0132959 --- /dev/null +++ b/go.work.sum @@ -0,0 +1 @@ +github.com/ugorji/go v1.2.7 h1:qYhyWUUd6WbiM+C6JZAUkIJt/1WrjzNHY9+KCIjVqTo= diff --git a/xumm-go-client b/xumm-go-client new file mode 160000 index 0000000..96aadd7 --- /dev/null +++ b/xumm-go-client @@ -0,0 +1 @@ +Subproject commit 96aadd7f8061ea2f1b4afb6580c3bfb0e1a02b11 diff --git a/xumm/jwt/jwt.go b/xumm/jwt/jwt.go index 8d84031..a66d49a 100644 --- a/xumm/jwt/jwt.go +++ b/xumm/jwt/jwt.go @@ -13,7 +13,7 @@ type JwtInterface interface { GetPayloadByCustomId(customId string, jwt ...string) (*models.XummPayload, error) GetRatesForCurrency(cur string, jwt ...string) (*models.RatesCurrencyResponse, error) PostPayload(body models.XummPostPayload, jwt ...string) (*models.CreatedPayload, error) - Ping(Jwt ...string) (*models.Pong, error) + Ping(Jwt ...string) (*models.JwtPong, error) } type Jwt struct { diff --git a/xumm/jwt/jwt_ping.go b/xumm/jwt/jwt_ping.go index c311bc5..272eacd 100644 --- a/xumm/jwt/jwt_ping.go +++ b/xumm/jwt/jwt_ping.go @@ -14,7 +14,7 @@ const ( ) // Ping method tests connectivity to XUMM api. -func (j *Jwt) Ping(jwt ...string) (*models.Pong, error) { +func (j *Jwt) Ping(jwt ...string) (*models.JwtPong, error) { req, err := http.NewRequest(http.MethodGet, j.Cfg.BaseURL+JWTPINGENDPOINT, nil) if jwt == nil { @@ -36,7 +36,7 @@ func (j *Jwt) Ping(jwt ...string) (*models.Pong, error) { log.Println(err) return nil, err } - var p models.Pong + var p models.JwtPong _, err = utils.DeserialiseRequest(&p, res.Body) if err != nil { return nil, err diff --git a/xumm/meta/get_account_meta_integration_test.go b/xumm/meta/get_account_meta_integration_test.go new file mode 100644 index 0000000..530b2df --- /dev/null +++ b/xumm/meta/get_account_meta_integration_test.go @@ -0,0 +1,24 @@ +package meta + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/xyield/xumm-go-client/xumm" + statictestdata "github.com/xyield/xumm-go-client/xumm/meta/static-test-data" +) + +func TestGetAccountMetaIntegrationTest(t *testing.T) { + + cfg, err := xumm.NewConfig() + assert.NoError(t, err) + m := &Meta{ + Cfg: cfg, + } + + am, err := m.GetAccountMeta(statictestdata.AccountMetaTestResult.Account) + + assert.NoError(t, err) + assert.NotEmpty(t, am) + assert.Equal(t, statictestdata.AccountMetaTestResult, am) +} diff --git a/xumm/meta/get_account_meta_test.go b/xumm/meta/get_account_meta_test.go new file mode 100644 index 0000000..5984144 --- /dev/null +++ b/xumm/meta/get_account_meta_test.go @@ -0,0 +1,91 @@ +package meta + +import ( + "net/http" + "testing" + + "github.com/stretchr/testify/assert" + testutils "github.com/xyield/xumm-go-client/utils/test-utils" + "github.com/xyield/xumm-go-client/xumm" + statictestdata "github.com/xyield/xumm-go-client/xumm/meta/static-test-data" + "github.com/xyield/xumm-go-client/xumm/models" +) + +func TestGetAccountMeta(t *testing.T) { + + jsonResponse := `{ + "account": "rwietsevLFg8XSmG3bEZzFein1g8RBqWDZ", + "kycApproved": true, + "xummPro": true, + "blocked": false, + "force_dtag": false, + "avatar": "https://xumm.app/avatar/rwietsevLFg8XSmG3bEZzFein1g8RBqWDZ.png", + "xummProfile": { + "accountAlias": "XRPL Labs - Wietse Wind", + "ownerAlias": "Wietse Wind", + "slug": "wietsewind", + "profileUrl": "https://xumm.me/wietsewind", + "accountSlug": null, + "payString": "wietsewind$xumm.me" + }, + "thirdPartyProfiles": [ + { + "accountAlias": "Wietse Wind", + "source": "xumm.app" + }, + { + "accountAlias": "wietse.com", + "source": "xrpl" + }, + { + "accountAlias": "XRPL-Labs", + "source": "bithomp.com" + } + ], + "globalid": { + "linked": "2021-06-29T10:22:25.000Z", + "profileUrl": "https://app.global.id/u/wietse", + "sufficientTrust": true + } + }` + + tests := []struct { + testName string + inputValue string + expectedOutput *models.AccountMetaResponse + expectedError error + httpStatusCode int + }{ + {testName: "correctData", inputValue: jsonResponse, expectedOutput: statictestdata.AccountMetaTestResult, expectedError: nil, httpStatusCode: 200}, + } + + for _, tt := range tests { + + t.Run(tt.testName, func(t *testing.T) { + m := &testutils.MockClient{} + m.DoFunc = testutils.MockResponse(tt.inputValue, tt.httpStatusCode, m) + cfg, err := xumm.NewConfig(xumm.WithHttpClient(m), xumm.WithAuth("testApiKey", "testApiSecret")) + assert.NoError(t, err) + meta := &Meta{ + Cfg: cfg, + } + ca, err := meta.GetAccountMeta(statictestdata.AccountMetaTestResult.Account) + + if tt.expectedError != nil { + assert.Nil(t, ca) + assert.Error(t, err) + assert.EqualError(t, err, tt.expectedError.Error()) + } else { + assert.Equal(t, http.Header{ + "X-API-Key": {"testApiKey"}, + "X-API-Secret": {"testApiSecret"}, + "Content-Type": {"application/json"}, + }, m.Spy.Header) + assert.NoError(t, err) + assert.Equal(t, tt.expectedOutput, ca) + } + }) + + } + +} diff --git a/xumm/meta/get_curated_assets_integration_test.go b/xumm/meta/get_curated_assets_integration_test.go index 2a46856..82b8553 100644 --- a/xumm/meta/get_curated_assets_integration_test.go +++ b/xumm/meta/get_curated_assets_integration_test.go @@ -33,7 +33,7 @@ func TestCuratedAssetsIntegration(t *testing.T) { Id: 185, Name: "Bitstamp", Domain: "bitstamp.net", - Avatar: "https://xumm.app/assets/icons/currencies/ex-bitstamp.png", + Avatar: "https://xumm.app/cdn-cgi/image/width=250,height=250,quality=75,fit=crop/assets/icons/currencies/ex-bitstamp.png", Currencies: map[string]models.CurrencyInfo{ "BTC": { Id: 492, @@ -41,7 +41,23 @@ func TestCuratedAssetsIntegration(t *testing.T) { Issuer: "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B", Currency: "BTC", Name: "Bitcoin", - Avatar: "https://xumm.app/assets/icons/currencies/crypto-btc.png", + Avatar: "https://xumm.app/cdn-cgi/image/width=250,height=250,quality=75,fit=crop/assets/icons/currencies/crypto-btc.png", + }, + "EUR": { + Id: 13854758, + IssuerId: 185, + Issuer: "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B", + Currency: "EUR", + Name: "Euro", + Avatar: "https://xumm.app/cdn-cgi/image/width=250,height=250,quality=75,fit=crop/assets/icons/currencies/fiat-euro.png", + }, + "GBP": { + Id: 13854774, + IssuerId: 185, + Issuer: "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B", + Currency: "GBP", + Name: "British Pound", + Avatar: "https://cdn.xumm.pro/cdn-cgi/image/width=250,height=250,quality=75,fit=crop/currencies-tokens/fiat-brpnd.png", }, "USD": { Id: 178, @@ -49,7 +65,7 @@ func TestCuratedAssetsIntegration(t *testing.T) { Issuer: "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B", Currency: "USD", Name: "US Dollar", - Avatar: "https://xumm.app/assets/icons/currencies/fiat-dollar.png", + Avatar: "https://xumm.app/cdn-cgi/image/width=250,height=250,quality=75,fit=crop/assets/icons/currencies/fiat-dollar.png", }, }, }, bitstamp) diff --git a/xumm/meta/get_hookhash.go b/xumm/meta/get_hookhash.go index 56e103f..ae0f052 100644 --- a/xumm/meta/get_hookhash.go +++ b/xumm/meta/get_hookhash.go @@ -1,6 +1,8 @@ package meta import ( + "encoding/hex" + "fmt" "net/http" "github.com/xyield/xumm-go-client/utils" @@ -12,7 +14,28 @@ const ( HOOKHASHENDPOINT = "/platform/hookhash/" ) -func (m *Meta) GetHookhash(h string) (*models.HookHashResponse, error) { +type EmptyHookHash struct{} + +func (e *EmptyHookHash) Error() string { + return fmt.Sprintln("No hookhash provided") +} + +type InvalidHookHash struct{} + +func (e *InvalidHookHash) Error() string { + return fmt.Sprintln("Invalid hookhash provided, must be 64 hexadecimal characters") +} + +func (m *Meta) GetHookHash(h string) (*models.HookHashResponse, error) { + + if len(h) != 64 { + return nil, &InvalidHookHash{} + } + + _, err := hex.DecodeString(h) + if err != nil { + return nil, &InvalidHookHash{} + } req, err := http.NewRequest(http.MethodGet, m.Cfg.BaseURL+HOOKHASHENDPOINT+h, nil) if err != nil { diff --git a/xumm/meta/get_hookhash_integration_test.go b/xumm/meta/get_hookhash_integration_test.go new file mode 100644 index 0000000..027da10 --- /dev/null +++ b/xumm/meta/get_hookhash_integration_test.go @@ -0,0 +1,30 @@ +//go:build integration +// +build integration + +package meta + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/xyield/xumm-go-client/xumm" + "github.com/xyield/xumm-go-client/xumm/models" +) + +func TestGetHookHashIntegrationTest(t *testing.T) { + + cfg, err := xumm.NewConfig() + assert.NoError(t, err) + m := &Meta{ + Cfg: cfg, + } + + hookHash := "31C3EC186C367DA66DFBD0E576D6170A2C1AB846BFC35FC0B49D202F2A8CDFD8" + + hh, err := m.GetHookHash(hookHash) + + assert.NoError(t, err) + assert.IsType(t, &models.HookHashResponse{}, hh) + assert.NotEmpty(t, hh.Name) + assert.NotEmpty(t, hh.Description) +} diff --git a/xumm/meta/get_hookhash_test.go b/xumm/meta/get_hookhash_test.go new file mode 100644 index 0000000..e315cb6 --- /dev/null +++ b/xumm/meta/get_hookhash_test.go @@ -0,0 +1,108 @@ +//go:build unit +// +build unit + +package meta + +import ( + "net/http" + "testing" + + "github.com/stretchr/testify/assert" + testutils "github.com/xyield/xumm-go-client/utils/test-utils" + "github.com/xyield/xumm-go-client/xumm" + "github.com/xyield/xumm-go-client/xumm/models" +) + +func TestGetHookhash(t *testing.T) { + + c := &models.HookHashResponse{ + Name: "testhookhash", + Description: "atesthookhash", + Creator: models.HookHashCreator{ + Name: "joebloggs", + Mail: "jb@gfail.com", + Site: "test.com", + }, + Xapp: "testXapp", + AppUUID: "testUUID", + Icon: "testIcon", + VerifiedAccounts: []string{"testva"}, + Audits: []string{"testaudits"}, + } + + validJson := `{ + "name": "testhookhash", + "description": "atesthookhash", + "creator": { + "name": "joebloggs", + "mail": "jb@gfail.com", + "site": "test.com" + }, + "xapp": "testXapp", + "appuuid": "testUUID", + "icon": "testIcon", + "verifiedaccounts": ["testva"], + "audits": ["testaudits"] + }` + + errorJson := `{ + "error": { + "reference": "3a04c7d3-94aa-4d8d-9559-62bb5e8a653c", + "code": 400 + "message": "Invalid hookhash provided, must be 64 hexadecimal characters" + } + }` + + var tests = []struct { + testName string + testValue string + inputValue string + expectedOutput *models.HookHashResponse + expectedError error + httpStatusCode int + }{ + { + testName: "GetHookhash - success", + testValue: "A17E4DEAD62BF705D9B73B4EAD2832F1C55C6C5A0067327A45E497FD8D31C0E3", + inputValue: validJson, + expectedOutput: c, + expectedError: nil, + httpStatusCode: http.StatusOK, + }, + { + testName: "GetHookhash - error response", + testValue: "invalidhookhash", + inputValue: errorJson, + expectedOutput: nil, + expectedError: &InvalidHookHash{}, + httpStatusCode: 400, + }, + } + for _, tt := range tests { + + t.Run(tt.testName, func(t *testing.T) { + m := &testutils.MockClient{} + m.DoFunc = testutils.MockResponse(tt.inputValue, tt.httpStatusCode, m) + cfg, err := xumm.NewConfig(xumm.WithHttpClient(m), xumm.WithAuth("testApiKey", "testApiSecret")) + assert.NoError(t, err) + meta := &Meta{ + Cfg: cfg, + } + ca, err := meta.GetHookHash(tt.testValue) + + if tt.expectedError != nil { + assert.Nil(t, ca) + assert.Error(t, err) + assert.EqualError(t, err, tt.expectedError.Error()) + } else { + assert.NoError(t, err) + assert.Equal(t, tt.expectedOutput, ca) + assert.Equal(t, http.Header{ + "X-API-Key": {"testApiKey"}, + "X-API-Secret": {"testApiSecret"}, + "Content-Type": {"application/json"}, + }, m.Spy.Header) + } + }) + } +} diff --git a/xumm/meta/get_hookhashes.go b/xumm/meta/get_hookhashes.go new file mode 100644 index 0000000..728e827 --- /dev/null +++ b/xumm/meta/get_hookhashes.go @@ -0,0 +1,33 @@ +package meta + +import ( + "net/http" + + "github.com/xyield/xumm-go-client/utils" + "github.com/xyield/xumm-go-client/xumm" + "github.com/xyield/xumm-go-client/xumm/models" +) + +func (m *Meta) GetHookHashes() (*models.HookHashesResponse, error) { + + req, err := http.NewRequest(http.MethodGet, m.Cfg.BaseURL+HOOKHASHENDPOINT, nil) + if err != nil { + return nil, err + } + req.Header = m.Cfg.GetHeaders() + res, err := m.Cfg.HTTPClient.Do(req) + if err != nil { + return nil, err + } + err = xumm.CheckForErrorResponse(res) + if err != nil { + return nil, err + } + var hh models.HookHashesResponse + _, err = utils.DeserialiseRequest(&hh, res.Body) + if err != nil { + return nil, err + } + + return &hh, nil +} diff --git a/xumm/meta/get_hookhashes_integration_test.go b/xumm/meta/get_hookhashes_integration_test.go new file mode 100644 index 0000000..d4c707f --- /dev/null +++ b/xumm/meta/get_hookhashes_integration_test.go @@ -0,0 +1,33 @@ +//go:build integration +// +build integration + +package meta + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/xyield/xumm-go-client/xumm" + "github.com/xyield/xumm-go-client/xumm/models" +) + +func TestGetHookHashesIntegrationTest(t *testing.T) { + + cfg, err := xumm.NewConfig() + assert.NoError(t, err) + m := &Meta{ + Cfg: cfg, + } + + hh, err := m.GetHookHashes() + + assert.NoError(t, err) + assert.IsType(t, &models.HookHashesResponse{}, hh) + assert.NotEmpty(t, hh) + + for _, hookHash := range *hh { + assert.NotEmpty(t, hookHash.Name) + assert.NotEmpty(t, hookHash.Description) + } + +} diff --git a/xumm/meta/get_hookhashes_test.go b/xumm/meta/get_hookhashes_test.go new file mode 100644 index 0000000..3c93b56 --- /dev/null +++ b/xumm/meta/get_hookhashes_test.go @@ -0,0 +1,208 @@ +//go:build unit +// +build unit + +package meta + +import ( + "net/http" + "testing" + + "github.com/stretchr/testify/assert" + testutils "github.com/xyield/xumm-go-client/utils/test-utils" + "github.com/xyield/xumm-go-client/xumm" + "github.com/xyield/xumm-go-client/xumm/models" +) + +func TestGetHookHashes(t *testing.T) { + + noHookHash := `{ + "31C3EC186C367DA66DFBD0E576D6170A2C1AB846BFC35FC0B49D202F2A8CDFD8": { + "name": "Savings", + "description": "Efficiently manage your finances with the savings hook by automatically transferring a percentage of your transaction amount to a separate savings account to prevent accidental spending", + "creator": { + "name": "XRPL Labs", + "mail": "support@xrpl-labs.com", + "site": "xrpl-labs.com" + }, + "xapp": "hooks.savings", + "appuuid": "d21fe83d-64b9-4aef-8908-9a4952d8922c", + "icon": "https://cdn.xumm.pro/cdn-cgi/image/width=500,height=500,quality=75,fit=crop/app-logo/1857a4e1-6711-4c37-bb54-7664e129e9bf.png", + "verifiedAccounts": [], + "audits": [] + }, + "FCEA17EB0A771899227CD1C22CD1BFC9C9B78017E6EAE0F576C6E78BAE9D57D4": { + "name": "Firewall", + "description": "Select which type of transactions you allow into and out of your account.", + "creator": { + "name": "XRPL Labs", + "mail": "support@xrpl-labs.com", + "site": "xrpl-labs.com" + }, + "xapp": "hooks.firewall", + "appuuid": "26447750-0063-4f81-9de4-c7a9bb8fe935", + "icon": "https://cdn.xumm.pro/cdn-cgi/image/width=500,height=500,quality=75,fit=crop/app-logo/9a1800d8-d2a3-4bbb-9cdd-e8e47850d65c.png", + "verifiedAccounts": [], + "audits": [] + }, + "C08FF0A3849F7D4A2F346DDB69282487BA320557516DC954C91CA81F05F478BB": { + "name": "Direct Debit", + "description": "Allow trusted third parties to pull funds from your account up to a limit you set. For example your power company can bill you and your account can automatically pay that bill.", + "creator": { + "name": "XRPL Labs", + "mail": "support@xrpl-labs.com", + "site": "xrpl-labs.com" + }, + "xapp": "hooks.directdebit", + "appuuid": "6df15d3e-7c6e-49a5-aceb-63df92e92fc2", + "icon": "https://cdn.xumm.pro/cdn-cgi/image/width=500,height=500,quality=75,fit=crop/app-logo/24738ef6-df4b-464c-9a07-5c9f01c76f00.png", + "verifiedAccounts": [], + "audits": [] + }, + "9B11CAAF4F87D2638CE86D3E82FE4A1464D95693B4C440B9048DCC5EFD91862B": { + "name": "Payment Watchdog", + "description": "When sending high value transactions out of your account, require first a notification that a high valued payment will be made, followed by a time delay, followed by the high value transaction itself. This prevents accidental high value sends, adding an additional layer of security to your account.", + "creator": { + "name": "XRPL Labs", + "mail": "support@xrpl-labs.com", + "site": "xrpl-labs.com" + }, + "xapp": "hooks.highvalueprotect", + "appuuid": "dcfe584f-8158-49ec-840a-3aea8819ce72", + "icon": "https://cdn.xumm.pro/cdn-cgi/image/width=500,height=500,quality=75,fit=crop/app-logo/1857a4e1-6711-4c37-bb54-7664e129e9bf.png", + "verifiedAccounts": [], + "audits": [] + }, + "???": { + "name": "Balance Adjustment", + "description": "Claim Xahau Balance Adjustment.", + "creator": { + "name": "Xahau", + "mail": "mail@xahau.network", + "site": "xahau.network" + }, + "xapp": "xahau.balanceadjustment", + "appuuid": "3b58aa5d-5263-4252-b230-f81ab0db9a7a", + "icon": "https://cdn.xumm.pro/cdn-cgi/image/width=500,height=500,quality=75,fit=crop/app-logo/3b1fd165-1923-4ed2-a48c-80709cd6a127.png", + "verifiedAccounts": [], + "audits": [] + } + }` + + hookhashresp := models.HookHashesResponse{ + "31C3EC186C367DA66DFBD0E576D6170A2C1AB846BFC35FC0B49D202F2A8CDFD8": models.HookHashResponse{ + Name: "Savings", + Description: "Efficiently manage your finances with the savings hook by automatically transferring a percentage of your transaction amount to a separate savings account to prevent accidental spending", + Creator: models.HookHashCreator{ + Name: "XRPL Labs", + Mail: "support@xrpl-labs.com", + Site: "xrpl-labs.com", + }, + Xapp: "hooks.savings", + AppUUID: "d21fe83d-64b9-4aef-8908-9a4952d8922c", + Icon: "https://cdn.xumm.pro/cdn-cgi/image/width=500,height=500,quality=75,fit=crop/app-logo/1857a4e1-6711-4c37-bb54-7664e129e9bf.png", + VerifiedAccounts: []string{}, + Audits: []string{}, + }, + "FCEA17EB0A771899227CD1C22CD1BFC9C9B78017E6EAE0F576C6E78BAE9D57D4": models.HookHashResponse{ + Name: "Firewall", + Description: "Select which type of transactions you allow into and out of your account.", + Creator: models.HookHashCreator{ + Name: "XRPL Labs", + Mail: "support@xrpl-labs.com", + Site: "xrpl-labs.com", + }, + Xapp: "hooks.firewall", + AppUUID: "26447750-0063-4f81-9de4-c7a9bb8fe935", + Icon: "https://cdn.xumm.pro/cdn-cgi/image/width=500,height=500,quality=75,fit=crop/app-logo/9a1800d8-d2a3-4bbb-9cdd-e8e47850d65c.png", + VerifiedAccounts: []string{}, + Audits: []string{}, + }, + "C08FF0A3849F7D4A2F346DDB69282487BA320557516DC954C91CA81F05F478BB": models.HookHashResponse{ + Name: "Direct Debit", + Description: "Allow trusted third parties to pull funds from your account up to a limit you set. For example your power company can bill you and your account can automatically pay that bill.", + Creator: models.HookHashCreator{ + Name: "XRPL Labs", + Mail: "support@xrpl-labs.com", + Site: "xrpl-labs.com", + }, + Xapp: "hooks.directdebit", + AppUUID: "6df15d3e-7c6e-49a5-aceb-63df92e92fc2", + Icon: "https://cdn.xumm.pro/cdn-cgi/image/width=500,height=500,quality=75,fit=crop/app-logo/24738ef6-df4b-464c-9a07-5c9f01c76f00.png", + VerifiedAccounts: []string{}, + Audits: []string{}, + }, + "9B11CAAF4F87D2638CE86D3E82FE4A1464D95693B4C440B9048DCC5EFD91862B": models.HookHashResponse{ + Name: "Payment Watchdog", + Description: "When sending high value transactions out of your account, require first a notification that a high valued payment will be made, followed by a time delay, followed by the high value transaction itself. This prevents accidental high value sends, adding an additional layer of security to your account.", + Creator: models.HookHashCreator{ + Name: "XRPL Labs", + Mail: "support@xrpl-labs.com", + Site: "xrpl-labs.com", + }, + Xapp: "hooks.highvalueprotect", + AppUUID: "dcfe584f-8158-49ec-840a-3aea8819ce72", + Icon: "https://cdn.xumm.pro/cdn-cgi/image/width=500,height=500,quality=75,fit=crop/app-logo/1857a4e1-6711-4c37-bb54-7664e129e9bf.png", + VerifiedAccounts: []string{}, + Audits: []string{}, + }, + "???": models.HookHashResponse{ + Name: "Balance Adjustment", + Description: "Claim Xahau Balance Adjustment.", + Creator: models.HookHashCreator{ + Name: "Xahau", + Mail: "mail@xahau.network", + Site: "xahau.network", + }, + Xapp: "xahau.balanceadjustment", + AppUUID: "3b58aa5d-5263-4252-b230-f81ab0db9a7a", + Icon: "https://cdn.xumm.pro/cdn-cgi/image/width=500,height=500,quality=75,fit=crop/app-logo/3b1fd165-1923-4ed2-a48c-80709cd6a127.png", + VerifiedAccounts: []string{}, + Audits: []string{}, + }, + } + + var tests = []struct { + testName string + inputValue string + expectedOutput *models.HookHashesResponse + expectedError error + httpStatusCode int + }{ + { + testName: "GetHookHashes - success", + inputValue: noHookHash, + expectedOutput: &hookhashresp, + expectedError: nil, + httpStatusCode: http.StatusOK, + }, + } + + for _, tt := range tests { + + t.Run(tt.testName, func(t *testing.T) { + m := &testutils.MockClient{} + m.DoFunc = testutils.MockResponse(tt.inputValue, tt.httpStatusCode, m) + cfg, err := xumm.NewConfig(xumm.WithHttpClient(m), xumm.WithAuth("testApiKey", "testApiSecret")) + assert.NoError(t, err) + meta := &Meta{ + Cfg: cfg, + } + ca, err := meta.GetHookHashes() + + if tt.expectedError != nil { + assert.Nil(t, ca) + assert.Error(t, err) + assert.EqualError(t, err, tt.expectedError.Error()) + } else { + assert.NoError(t, err) + assert.Equal(t, tt.expectedOutput, ca) + assert.Equal(t, http.Header{ + "X-API-Key": {"testApiKey"}, + "X-API-Secret": {"testApiSecret"}, + "Content-Type": {"application/json"}, + }, m.Spy.Header) + } + }) + } + +} diff --git a/xumm/meta/get_rails_integration_test.go b/xumm/meta/get_rails_integration_test.go new file mode 100644 index 0000000..6069241 --- /dev/null +++ b/xumm/meta/get_rails_integration_test.go @@ -0,0 +1,29 @@ +//go:build integration +// +build integration + +package meta + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/xyield/xumm-go-client/xumm" + statictestdata "github.com/xyield/xumm-go-client/xumm/meta/static-test-data" + "github.com/xyield/xumm-go-client/xumm/models" +) + +func TestGetRailsIntegrationTest(t *testing.T) { + + cfg, err := xumm.NewConfig() + assert.NoError(t, err) + m := &Meta{ + Cfg: cfg, + } + + r, err := m.GetRails() + assert.NoError(t, err) + assert.NotEmpty(t, r) + assert.IsType(t, &models.RailsResponse{}, r) + assert.Equal(t, statictestdata.RailsResponseResult, r) + +} diff --git a/xumm/meta/get_rails_test.go b/xumm/meta/get_rails_test.go new file mode 100644 index 0000000..325b229 --- /dev/null +++ b/xumm/meta/get_rails_test.go @@ -0,0 +1,255 @@ +//go:build unit +// +build unit + +package meta + +import ( + "net/http" + "testing" + + "github.com/stretchr/testify/assert" + testutils "github.com/xyield/xumm-go-client/utils/test-utils" + "github.com/xyield/xumm-go-client/xumm" + statictestdata "github.com/xyield/xumm-go-client/xumm/meta/static-test-data" + "github.com/xyield/xumm-go-client/xumm/models" +) + +func TestGetRails(t *testing.T) { + railsJson := `{ + "MAINNET": { + "chain_id": 0, + "color": "#4CA1F8", + "name": "XRPL Mainnet", + "is_livenet": true, + "native_asset": "XRP", + "endpoints": [ + { + "name": "XRPLCluster.com (XRPLF)", + "url": "wss://xrplcluster.com" + }, + { + "name": "Ripple S2 (Ripple)", + "url": "wss://s2.ripple.com" + }, + { + "name": "xrpl.link (XRPLF, fallback)", + "url": "wss://xrpl.link" + } + ], + "explorers": [ + { + "name": "Bithomp Explorer", + "url_tx": "https://bithomp.com/explorer/", + "url_ctid": "https://bithomp.com/explorer/", + "url_account": "https://bithomp.com/explorer/" + }, + { + "name": "XRP Scan", + "url_tx": "https://xrpscan.com/tx/", + "url_account": "https://xrpscan.com/account/" + }, + { + "name": "XRPL.org Livenet Explorer", + "url_tx": "https://livenet.xrpl.org/transactions/", + "url_account": "https://livenet.xrpl.org/accounts/" + }, + { + "name": "XRPLF Technical Explorer", + "url_tx": "https://explorer.xrplf.org/tx/", + "url_ctid": "https://explorer.xrplf.org/", + "url_account": "https://explorer.xrplf.org/" + } + ], + "rpc": "https://xrplcluster.com", + "definitions": "default", + "icons": { + "icon_square": "data:image/png;base64,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", + "icon_asset": "data:image/png;base64,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" + } + }, + "TESTNET": { + "chain_id": 1, + "color": "#FF6719", + "name": "XRPL Testnet", + "is_livenet": false, + "native_asset": "XRP", + "faucet": "https://faucet.altnet.rippletest.net/accounts", + "xpop_endpoints": [ + "https://testnet.xrpl-labs.com/xpop/" + ], + "endpoints": [ + { + "name": "XRPL Labs Testnet", + "url": "wss://testnet.xrpl-labs.com" + }, + { + "name": "Ripple XRPL Testnet", + "url": "wss://s.altnet.rippletest.net:51233" + } + ], + "explorers": [ + { + "name": "Bithomp Testnet Explorer", + "url_tx": "https://test.bithomp.com/explorer/", + "url_ctid": "https://test.bithomp.com/explorer/", + "url_account": "https://test.bithomp.com/explorer/" + }, + { + "name": "XRPL.org Testnet Explorer", + "url_tx": "https://testnet.xrpl.org/transactions/", + "url_account": "https://testnet.xrpl.org/accounts/" + }, + { + "name": "XRPLF Technical Explorer", + "url_tx": "https://explorer-testnet.xrplf.org/tx/", + "url_account": "https://explorer-testnet.xrplf.org/", + "url_ctid": "https://explorer-testnet.xrplf.org/" + } + ], + "rpc": "https://testnet.xrpl-labs.com", + "definitions": "default", + "icons": { + "icon_square": "data:image/png;base64,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", + "icon_asset": "data:image/png;base64,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" + } + }, + "DEVNET": { + "chain_id": 2, + "color": "#B480FF", + "name": "XRPL Devnet", + "is_livenet": false, + "native_asset": "XRP", + "faucet": "https://faucet.devnet.rippletest.net/accounts", + "endpoints": [ + { + "name": "Ripple XRPL Devnet", + "url": "wss://s.devnet.rippletest.net:51233" + } + ], + "explorers": [ + { + "name": "XRPL.org Devnet Explorer", + "url_tx": "https://devnet.xrpl.org/transactions/", + "url_account": "https://devnet.xrpl.org/accounts/" + } + ], + "rpc": "https://s.devnet.rippletest.net:51234", + "definitions": "default", + "icons": { + "icon_square": "data:image/png;base64,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", + "icon_asset": "data:image/png;base64,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" + } + }, + "XAHAU": { + "chain_id": 21337, + "color": "#0E0143", + "name": "Xahau Mainnet", + "is_livenet": true, + "native_asset": "XAH", + "endpoints": [ + { + "name": "Xahau Nodes (XRPL Labs)", + "url": "wss://xahau.network" + } + ], + "explorers": [ + { + "name": "Bithomp Explorer", + "url_tx": "https://xahau.bithomp.com/explorer/", + "url_ctid": "https://xahau.bithomp.com/explorer/", + "url_account": "https://xahau.bithomp.com/explorer/" + }, + { + "name": "XRPLF Technical Explorer", + "url_tx": "https://hooks-testnet-v3-explorer.xrpl-labs.com/", + "url_account": "https://hooks-testnet-v3-explorer.xrpl-labs.com/", + "_url_account": "https://explorer.xahau.network/" + } + ], + "rpc": "https://xahau.network", + "definitions": "xahau", + "icons": { + "icon_square": "data:image/png;base64,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", + "icon_asset": "data:image/png;base64,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" + } + }, + "XAHAUTESTNET": { + "chain_id": 21338, + "color": "#C0E12B", + "name": "Xahau Testnet", + "is_livenet": false, + "native_asset": "XAH", + "faucet": "https://xahau-test.net/accounts", + "endpoints": [ + { + "name": "Xahau Nodes (XRPL Labs)", + "url": "wss://xahau-test.net" + } + ], + "explorers": [ + { + "name": "Bithomp Explorer", + "url_tx": "https://test.xahauexplorer.com/explorer/", + "url_ctid": "https://test.xahauexplorer.com/explorer/", + "url_account": "https://test.xahauexplorer.com/explorer/" + }, + { + "name": "XRPLF Technical Explorer", + "url_tx": "https://explorer.xahau-test.net/tx/", + "url_account": "https://explorer.xahau-test.net/", + "url_ctid": "https://explorer.xahau-test.net/" + } + ], + "rpc": "https://xahau-test.net/", + "definitions": "xahau", + "icons": { + "icon_square": "data:image/png;base64,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", + "icon_asset": "data:image/png;base64,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" + } + } +}` + + var tests = []struct { + testName string + inputValue string + expectedOutput *models.RailsResponse + expectedError error + httpStatusCode int + }{ + { + testName: "GetHookHashes - success", + inputValue: railsJson, + expectedOutput: statictestdata.RailsResponseResult, + expectedError: nil, + httpStatusCode: http.StatusOK, + }, + } + + for _, tt := range tests { + + t.Run(tt.testName, func(t *testing.T) { + m := &testutils.MockClient{} + m.DoFunc = testutils.MockResponse(tt.inputValue, tt.httpStatusCode, m) + cfg, err := xumm.NewConfig(xumm.WithHttpClient(m), xumm.WithAuth("testApiKey", "testApiSecret")) + assert.NoError(t, err) + meta := &Meta{ + Cfg: cfg, + } + ca, err := meta.GetRails() + + if tt.expectedError != nil { + assert.Nil(t, ca) + assert.Error(t, err) + assert.EqualError(t, err, tt.expectedError.Error()) + } else { + assert.NoError(t, err) + assert.Equal(t, tt.expectedOutput, ca) + assert.Equal(t, http.Header{ + "X-API-Key": {"testApiKey"}, + "X-API-Secret": {"testApiSecret"}, + "Content-Type": {"application/json"}, + }, m.Spy.Header) + } + }) + } +} diff --git a/xumm/meta/meta.go b/xumm/meta/meta.go index 8caa832..f0ede3d 100644 --- a/xumm/meta/meta.go +++ b/xumm/meta/meta.go @@ -13,7 +13,8 @@ type MetaInterface interface { GetRatesForCurrency(cur string) (*models.RatesCurrencyResponse, error) GetXrplTransaction(txid string) (*models.XrpTxResponse, error) GetAccountMeta(a string) (*models.AccountMetaResponse, error) - GetHookhash(h string) (*models.HookHashResponse, error) + GetHookHash(h string) (*models.HookHashResponse, error) + GetHookHashes() (*models.HookHashesResponse, error) GetRails() (*models.RailsResponse, error) VerifyUserToken(t string) (*models.UserTokenResponse, error) VerifyUserTokens(uts ...string) (*models.UserTokenResponse, error) diff --git a/xumm/meta/ping_integration_test.go b/xumm/meta/ping_integration_test.go index 01d0cd0..de69e40 100644 --- a/xumm/meta/ping_integration_test.go +++ b/xumm/meta/ping_integration_test.go @@ -23,9 +23,10 @@ func TestPingIntegration(t *testing.T) { assert.NoError(t, err) assert.Equal(t, models.Application{ - UUIDV4: "eda1fbb4-8641-47bd-91c8-3adca27cd6e3", - Name: "Test Xumm App", - Disabled: 0, + UUIDV4: "eda1fbb4-8641-47bd-91c8-3adca27cd6e3", + Name: "Test Xumm App", + WebhookUrl: "https://32fc-115-189-103-75.ngrok-free.app/webhook", + Disabled: 0, }, pong.Auth.Application) assert.True(t, pong.Pong) assert.True(t, testutils.IsValidUUID(pong.Auth.Call.UUIDV4)) diff --git a/xumm/meta/static-test-data/account_meta_result.go b/xumm/meta/static-test-data/account_meta_result.go new file mode 100644 index 0000000..6c1c052 --- /dev/null +++ b/xumm/meta/static-test-data/account_meta_result.go @@ -0,0 +1,39 @@ +package statictestdata + +import "github.com/xyield/xumm-go-client/xumm/models" + +var AccountMetaTestResult = &models.AccountMetaResponse{ + Account: "rwietsevLFg8XSmG3bEZzFein1g8RBqWDZ", + KycApproved: true, + XummPro: true, + Blocked: false, + ForceDtag: false, + Avatar: "https://xumm.app/avatar/rwietsevLFg8XSmG3bEZzFein1g8RBqWDZ.png", + XummProfile: models.XummProfile{ + AccountAlias: "XRPL Labs - Wietse Wind", + OwnerAlias: "Wietse Wind", + Slug: "wietsewind", + ProfileURL: "https://xumm.me/wietsewind", + AccountSlug: "", + PayString: "wietsewind$xumm.me", + }, + ThirdPartyProfiles: []models.ThirdPartyProfile{ + { + AccountAlias: "Wietse Wind", + Source: "xumm.app", + }, + { + AccountAlias: "wietse.com", + Source: "xrpl", + }, + { + AccountAlias: "XRPL-Labs", + Source: "bithomp.com", + }, + }, + GlobalID: models.GlobalID{ + Linked: "2021-06-29T10:22:25.000Z", + ProfileURL: "https://app.global.id/u/wietse", + SufficientTrust: true, + }, +} diff --git a/xumm/meta/static-test-data/rails_result.go b/xumm/meta/static-test-data/rails_result.go new file mode 100644 index 0000000..71943b5 --- /dev/null +++ b/xumm/meta/static-test-data/rails_result.go @@ -0,0 +1,198 @@ +package statictestdata + +import "github.com/xyield/xumm-go-client/xumm/models" + +var RailsResponseResult = &models.RailsResponse{ + models.MAINNET: models.Rail{ + ChainID: models.MainnetChainID, + Color: models.MainnetColor, + Name: models.MainnetName, + IsLivenet: models.MainnetIsLivenet, + NativeAsset: models.MainnetNativeAsset, + Endpoints: []models.RailsEndpoint{ + { + Name: models.MainnetEndpointsXRPLClusterName, + Url: models.MainnetEndpointsXRPLClusterUrl, + }, + { + Name: models.MainnetEndpointsRippleS2Name, + Url: models.MainnetEndpointsRippleS2Url, + }, + { + Name: models.MainnetEndpointsXRPLFallbackName, + Url: models.MainnetEndpointsXRPLFallbackUrl, + }, + }, + Explorers: []models.RailsExplorer{ + { + Name: models.MainnetExplorersBithompName, + URLTx: models.MainnetExplorersBithompURLTx, + URLCTID: models.MainnetExplorersBithompURLCTID, + URLAccount: models.MainnetExplorersBithompURLAccount, + }, + { + Name: models.MainnetExplorersXRPScanName, + URLTx: models.MainnetExplorersXRPScanURLTx, + URLAccount: models.MainnetExplorersXRPScanURLAccount, + }, + { + Name: models.MainnetExplorersXRPLOrgName, + URLTx: models.MainnetExplorersXRPLOrgURLTx, + URLAccount: models.MainnetExplorersXRPLOrgURLAccount, + }, + { + Name: models.MainnetExplorersXRPLFTechnicalName, + URLTx: models.MainnetExplorersXRPLFTechnicalURLTx, + URLCTID: models.MainnetExplorersXRPLFTechnicalCTID, + URLAccount: models.MainnetExplorersXRPLFTechnicalURLAccount, + }, + }, + RPC: models.MainnetRPC, + Definitions: models.MainnetDefinitions, + Icons: models.RailsIcon{ + IconSquare: models.MainnetIconSquare, + IconAsset: models.MainnetIconAsset, + }, + }, + models.TESTNET: models.Rail{ + ChainID: models.TestnetChainID, + Color: models.TestnetColor, + Name: models.TestnetName, + IsLivenet: models.TestnetIsLivenet, + NativeAsset: models.TestnetNativeAsset, + Faucet: models.TestnetFaucet, + XpopEndpoints: []models.XpopEndpoints{ + models.TestnetXpopEndpointXRPLLabs, + }, + Endpoints: []models.RailsEndpoint{ + { + Name: models.TestnetEndpointsXRPLLabsTestnetName, + Url: models.TestnetEndpointsXRPLLabsTestnetUrl, + }, + { + Name: models.TestnetEndpointsRippleXRPLTestnetName, + Url: models.TestnetEndpointsRippleXRPLTestnetUrl, + }, + }, + Explorers: []models.RailsExplorer{ + { + Name: models.TestnetExplorersBithompName, + URLTx: models.TestnetExplorersBithompURLTx, + URLCTID: models.TestnetExplorersBithompURLCTID, + URLAccount: models.TestnetExplorersBithompURLAccount, + }, + { + Name: models.TestnetExplorersXRPLOrgName, + URLTx: models.TestnetExplorersXRPLOrgURLTx, + URLAccount: models.TestnetExplorersXRPLOrgURLAccount, + }, + { + Name: models.TestnetExplorersXRPLFTechnicalName, + URLTx: models.TestnetExplorersXRPLFTechnicalURLTx, + URLAccount: models.TestnetExplorersXRPLFTechnicalURLAccount, + URLCTID: models.TestnetExplorersXRPLFTechnicalURLCTID, + }, + }, + RPC: models.TestnetRPC, + Definitions: models.TestnetDefinitions, + Icons: models.RailsIcon{ + IconSquare: models.TestnetIconSquare, + IconAsset: models.TestnetIconAsset, + }, + }, + models.DEVNET: models.Rail{ + ChainID: models.DevnetChainID, + Color: models.DevnetColor, + Name: models.DevnetName, + IsLivenet: models.DevnetIsLivenet, + NativeAsset: models.DevnetNativeAsset, + Faucet: models.DevnetFaucet, + Endpoints: []models.RailsEndpoint{ + { + Name: models.DevnetEndpointsRippleXRPLDevnetName, + Url: models.DevnetEndpointsRippleXRPLDevnetUrl, + }, + }, + Explorers: []models.RailsExplorer{ + { + Name: models.DevnetExplorersXRPLOrgName, + URLTx: models.DevnetExplorersXRPLOrgURLTx, + URLAccount: models.DevnetExplorersXRPLOrgURLAccount, + }, + }, + RPC: models.DevnetRPC, + Definitions: models.DevnetDefinitions, + Icons: models.RailsIcon{ + IconSquare: models.DevnetIconSquare, + IconAsset: models.DevnetIconAsset, + }, + }, + models.XAHAU: models.Rail{ + ChainID: models.XahauChainID, + Color: models.XahauColor, + Name: models.XahauName, + IsLivenet: models.XahauIsLivenet, + NativeAsset: models.XahauNativeAsset, + Endpoints: []models.RailsEndpoint{ + { + Name: models.XahauEndpointsXahauNetworkName, + Url: models.XahauEndpointsXahauNetworkUrl, + }, + }, + Explorers: []models.RailsExplorer{ + { + Name: models.XahauExplorersBithompName, + URLTx: models.XahauExplorersBithompURLTx, + URLCTID: models.XahauExplorersBithompURLCTID, + URLAccount: models.XahauExplorersBithompURLAccount, + }, + { + Name: models.XahauExplorersXRPLFTechnicalName, + URLTx: models.XahauExplorersXRPLFTechnicalURLTx, + URLAccount: models.XahauExplorersXRPLFTechnicalURLAccount, + URLAccountNonExp: models.XahauExplorersXRPLFTechnicalURLAccountNonExp, + }, + }, + RPC: models.XahauRPC, + Definitions: models.XahauDefinitions, + Icons: models.RailsIcon{ + IconSquare: models.XahauIconSquare, + IconAsset: models.XahauIconAsset, + }, + }, + models.XAHAUTESTNET: models.Rail{ + ChainID: models.XahauTestnetChainID, + Color: models.XahauTestnetColor, + Name: models.XahauTestnetName, + IsLivenet: models.XahauTestnetIsLivenet, + NativeAsset: models.XahauTestnetNativeAsset, + Faucet: models.XahauTestnetFaucet, + Endpoints: []models.RailsEndpoint{ + { + Name: models.XahauTestnetEndpointsXahauTestnetName, + Url: models.XahauTestnetEndpointsXahauTestnetUrl, + }, + }, + Explorers: []models.RailsExplorer{ + { + Name: models.XahauTestnetExplorersBithompName, + URLTx: models.XahauTestnetExplorersBithompURLTx, + URLCTID: models.XahauTestnetExplorersBithompURLCTID, + URLAccount: models.XahauTestnetExplorersBithompURLAccount, + }, + { + Name: models.XahauTestnetExplorersXRPLFTechnicalName, + URLTx: models.XahauTestnetExplorersXRPLFTechnicalURLTx, + URLAccount: models.XahauTestnetExplorersXRPLFTechnicalURLAccount, + URLCTID: models.XahauTestnetExplorersXRPLFTechnicalURLCTID, + }, + }, + + RPC: models.XahauTestnetRPC, + Definitions: models.XahauTestnetDefinitions, + Icons: models.RailsIcon{ + IconSquare: models.XahauTestnetIconSquare, + IconAsset: models.XahauTestnetIconAsset, + }, + }, +} diff --git a/xumm/models/account_meta.go b/xumm/models/account_meta.go index 1803a13..5782190 100644 --- a/xumm/models/account_meta.go +++ b/xumm/models/account_meta.go @@ -1,6 +1,11 @@ package models type AccountMetaResponse struct { + Account string `json:"account"` + KycApproved bool `json:"kycApproved"` + XummPro bool `json:"xummPro"` + Blocked bool `json:"blocked"` + ForceDtag bool `json:"force_dtag"` Avatar string `json:"avatar,omitempty"` XummProfile XummProfile `json:"xummProfile,omitempty"` ThirdPartyProfiles []ThirdPartyProfile `json:"thirdPartyProfiles,omitempty"` @@ -10,6 +15,10 @@ type AccountMetaResponse struct { type XummProfile struct { AccountAlias string `json:"accountAlias,omitempty"` OwnerAlias string `json:"ownerAlias,omitempty"` + Slug string `json:"slug,omitempty"` + ProfileURL string `json:"profileUrl,omitempty"` + AccountSlug string `json:"accountSlug,omitempty"` + PayString string `json:"payString,omitempty"` } type ThirdPartyProfile struct { @@ -18,6 +27,7 @@ type ThirdPartyProfile struct { } type GlobalID struct { - Linked string `json:"linked,omitempty"` - ProfileURL string `json:"profileUrl,omitempty"` + Linked string `json:"linked,omitempty"` + ProfileURL string `json:"profileUrl,omitempty"` + SufficientTrust bool `json:"sufficientTrust"` } diff --git a/xumm/models/application.go b/xumm/models/application.go index 7e1714d..b6a6cd5 100644 --- a/xumm/models/application.go +++ b/xumm/models/application.go @@ -6,3 +6,17 @@ type Application struct { WebhookUrl string `json:"webhookurl,omitempty"` Disabled int `json:"disabled,omitempty"` } + +type ApplicationDetails struct { + Quota map[string]interface{} `json:"quota,omitempty"` + Application Application `json:"application"` + Call Call `json:"call,omitempty"` + JwtData JwtPong `json:"jwtData,omitempty"` +} + +type AppDetails struct { + UUIDv4 string `json:"uuidv4"` + Name string `json:"name"` + WebhookURL *string `json:"webhookurl,omitempty"` + Disabled *int `json:"disabled,omitempty"` +} diff --git a/xumm/models/curated_assets_response.go b/xumm/models/curated_assets_response.go index 64d40c6..1520c47 100644 --- a/xumm/models/curated_assets_response.go +++ b/xumm/models/curated_assets_response.go @@ -11,14 +11,16 @@ type Issuer struct { Name string `json:"name"` Domain string `json:"domain,omitempty"` Avatar string `json:"avatar,omitempty"` + Shortlist int `json:"shortlist"` Currencies map[string]CurrencyInfo `json:"currencies"` } type CurrencyInfo struct { - Id int64 `json:"id"` - IssuerId int64 `json:"issuer_id"` - Issuer string `json:"issuer"` - Currency string `json:"currency"` - Name string `json:"name"` - Avatar string `json:"avatar,omitempty"` + Id int64 `json:"id"` + IssuerId int64 `json:"issuer_id"` + Issuer string `json:"issuer"` + Currency string `json:"currency"` + Name string `json:"name"` + Avatar string `json:"avatar,omitempty"` + Shortlist int `json:"shortlist"` } diff --git a/xumm/models/hookhash_response.go b/xumm/models/hookhash_response.go index e4063b6..b3f3c74 100644 --- a/xumm/models/hookhash_response.go +++ b/xumm/models/hookhash_response.go @@ -1,8 +1,8 @@ package models type HookHashResponse struct { - Name string `json:"name,omitempty"` - Description string `json:"description,omitempty"` + Name string `json:"name"` + Description string `json:"description"` Creator HookHashCreator `json:"creator,omitempty"` Xapp string `json:"xapp,omitempty"` AppUUID string `json:"appuuid,omitempty"` diff --git a/xumm/models/hookhashes_response.go b/xumm/models/hookhashes_response.go new file mode 100644 index 0000000..bcf91b6 --- /dev/null +++ b/xumm/models/hookhashes_response.go @@ -0,0 +1,3 @@ +package models + +type HookHashesResponse map[string]HookHashResponse diff --git a/xumm/models/jwt_pong.go b/xumm/models/jwt_pong.go new file mode 100644 index 0000000..39f9cde --- /dev/null +++ b/xumm/models/jwt_pong.go @@ -0,0 +1,18 @@ +package models + +type JwtPong struct { + Pong bool `json:"pong"` + ClientID string `json:"client_id"` + State string `json:"state,omitempty"` + Scope string `json:"scope,omitempty"` + Nonce string `json:"nonce,omitempty"` + Aud string `json:"aud"` + Sub string `json:"sub"` + AppUUIDv4 string `json:"app_uuidv4"` + AppName string `json:"app_name"` + PayloadUUIDv4 string `json:"payload_uuidv4"` + UserTokenUUIDv4 string `json:"usertoken_uuidv4"` + Iat int `json:"iat"` + Exp int `json:"exp"` + Iss string `json:"iss"` +} diff --git a/xumm/models/kyc_account_status.go b/xumm/models/kyc_info_response.go similarity index 100% rename from xumm/models/kyc_account_status.go rename to xumm/models/kyc_info_response.go diff --git a/xumm/models/kyc_status_state_request.go b/xumm/models/kyc_status_request.go similarity index 100% rename from xumm/models/kyc_status_state_request.go rename to xumm/models/kyc_status_request.go diff --git a/xumm/models/kyc_status_state_response.go b/xumm/models/kyc_status_response.go similarity index 100% rename from xumm/models/kyc_status_state_response.go rename to xumm/models/kyc_status_response.go diff --git a/xumm/models/nftoken_detail.go b/xumm/models/nftoken_detail.go new file mode 100644 index 0000000..ff9c320 --- /dev/null +++ b/xumm/models/nftoken_detail.go @@ -0,0 +1,9 @@ +package models + +type NftokenDetail struct { + Issuer string `json:"issuer,omitempty"` + Token string `json:"token,omitempty"` + Owner string `json:"owner,omitempty"` + Name string `json:"name,omitempty"` + Image string `json:"image,omitempty"` +} diff --git a/xumm/models/pong.go b/xumm/models/pong.go index 72ebeb3..60a460a 100644 --- a/xumm/models/pong.go +++ b/xumm/models/pong.go @@ -5,12 +5,6 @@ type Pong struct { Auth ApplicationDetails `json:"auth"` } -type ApplicationDetails struct { - Quota map[string]interface{} `json:"quota"` - Application Application `json:"application"` - Call Call `json:"call"` -} - type Call struct { UUIDV4 string `json:"uuidv4"` } diff --git a/xumm/models/rails_response.go b/xumm/models/rails_response.go index 803ac0a..5970de5 100644 --- a/xumm/models/rails_response.go +++ b/xumm/models/rails_response.go @@ -1,36 +1,184 @@ package models -type RailsResponse struct { -} +const ( + MAINNET = "MAINNET" + TESTNET = "TESTNET" + DEVNET = "DEVNET" + XAHAU = "XAHAU" + XAHAUTESTNET = "XAHAUTESTNET" + + MainnetChainID = 0 + TestnetChainID = 1 + DevnetChainID = 2 + XahauChainID = 21337 + XahauTestnetChainID = 21338 + + MainnetColor = "#4CA1F8" + TestnetColor = "#FF6719" + DevnetColor = "#B480FF" + XahauColor = "#0E0143" + XahauTestnetColor = "#C0E12B" + + MainnetName = "XRPL Mainnet" + TestnetName = "XRPL Testnet" + DevnetName = "XRPL Devnet" + XahauName = "Xahau Mainnet" + XahauTestnetName = "Xahau Testnet" + + MainnetIsLivenet = true + TestnetIsLivenet = false + DevnetIsLivenet = false + XahauIsLivenet = true + XahauTestnetIsLivenet = false + + MainnetNativeAsset = "XRP" + TestnetNativeAsset = "XRP" + DevnetNativeAsset = "XRP" + XahauNativeAsset = "XAH" + XahauTestnetNativeAsset = "XAH" + + MainnetFaucet = "" + TestnetFaucet = "https://faucet.altnet.rippletest.net/accounts" + DevnetFaucet = "https://faucet.devnet.rippletest.net/accounts" + XahauFaucet = "" + XahauTestnetFaucet = "https://xahau-test.net/accounts" + + TestnetXpopEndpointXRPLLabs = "https://testnet.xrpl-labs.com/xpop/" + + MainnetEndpointsXRPLClusterName = "XRPLCluster.com (XRPLF)" + MainnetEndpointsXRPLClusterUrl = "wss://xrplcluster.com" + MainnetEndpointsRippleS2Name = "Ripple S2 (Ripple)" + MainnetEndpointsRippleS2Url = "wss://s2.ripple.com" + MainnetEndpointsXRPLFallbackName = "xrpl.link (XRPLF, fallback)" + MainnetEndpointsXRPLFallbackUrl = "wss://xrpl.link" + + TestnetEndpointsXRPLLabsTestnetName = "XRPL Labs Testnet" + TestnetEndpointsXRPLLabsTestnetUrl = "wss://testnet.xrpl-labs.com" + TestnetEndpointsRippleXRPLTestnetName = "Ripple XRPL Testnet" + TestnetEndpointsRippleXRPLTestnetUrl = "wss://s.altnet.rippletest.net:51233" + + DevnetEndpointsRippleXRPLDevnetName = "Ripple XRPL Devnet" + DevnetEndpointsRippleXRPLDevnetUrl = "wss://s.devnet.rippletest.net:51233" + + XahauEndpointsXahauNetworkName = "Xahau Nodes (XRPL Labs)" + XahauEndpointsXahauNetworkUrl = "wss://xahau.network" + + XahauTestnetEndpointsXahauTestnetName = "Xahau Nodes (XRPL Labs)" + XahauTestnetEndpointsXahauTestnetUrl = "wss://xahau-test.net" + + MainnetExplorersBithompName = "Bithomp Explorer" + MainnetExplorersBithompURLTx = "https://bithomp.com/explorer/" + MainnetExplorersBithompURLCTID = "https://bithomp.com/explorer/" + MainnetExplorersBithompURLAccount = "https://bithomp.com/explorer/" + + MainnetExplorersXRPScanName = "XRP Scan" + MainnetExplorersXRPScanURLTx = "https://xrpscan.com/tx/" + MainnetExplorersXRPScanURLAccount = "https://xrpscan.com/account/" + + MainnetExplorersXRPLOrgName = "XRPL.org Livenet Explorer" + MainnetExplorersXRPLOrgURLTx = "https://livenet.xrpl.org/transactions/" + MainnetExplorersXRPLOrgURLAccount = "https://livenet.xrpl.org/accounts/" + + MainnetExplorersXRPLFTechnicalName = "XRPLF Technical Explorer" + MainnetExplorersXRPLFTechnicalURLTx = "https://explorer.xrplf.org/tx/" + MainnetExplorersXRPLFTechnicalCTID = "https://explorer.xrplf.org/" + MainnetExplorersXRPLFTechnicalURLAccount = "https://explorer.xrplf.org/" + + TestnetExplorersBithompName = "Bithomp Testnet Explorer" + TestnetExplorersBithompURLTx = "https://test.bithomp.com/explorer/" + TestnetExplorersBithompURLCTID = "https://test.bithomp.com/explorer/" + TestnetExplorersBithompURLAccount = "https://test.bithomp.com/explorer/" + + TestnetExplorersXRPLOrgName = "XRPL.org Testnet Explorer" + TestnetExplorersXRPLOrgURLTx = "https://testnet.xrpl.org/transactions/" + TestnetExplorersXRPLOrgURLAccount = "https://testnet.xrpl.org/accounts/" + + TestnetExplorersXRPLFTechnicalName = "XRPLF Technical Explorer" + TestnetExplorersXRPLFTechnicalURLTx = "https://explorer-testnet.xrplf.org/tx/" + TestnetExplorersXRPLFTechnicalURLAccount = "https://explorer-testnet.xrplf.org/" + TestnetExplorersXRPLFTechnicalURLCTID = "https://explorer-testnet.xrplf.org/" + + DevnetExplorersXRPLOrgName = "XRPL.org Devnet Explorer" + DevnetExplorersXRPLOrgURLTx = "https://devnet.xrpl.org/transactions/" + DevnetExplorersXRPLOrgURLAccount = "https://devnet.xrpl.org/accounts/" + + XahauExplorersBithompName = "Bithomp Explorer" + XahauExplorersBithompURLTx = "https://xahau.bithomp.com/explorer/" + XahauExplorersBithompURLCTID = "https://xahau.bithomp.com/explorer/" + XahauExplorersBithompURLAccount = "https://xahau.bithomp.com/explorer/" + + XahauExplorersXRPLFTechnicalName = "XRPLF Technical Explorer" + XahauExplorersXRPLFTechnicalURLTx = "https://hooks-testnet-v3-explorer.xrpl-labs.com/" + XahauExplorersXRPLFTechnicalURLAccount = "https://hooks-testnet-v3-explorer.xrpl-labs.com/" + XahauExplorersXRPLFTechnicalURLAccountNonExp = "https://explorer.xahau.network/" + + XahauTestnetExplorersBithompName = "Bithomp Explorer" + XahauTestnetExplorersBithompURLTx = "https://test.xahauexplorer.com/explorer/" + XahauTestnetExplorersBithompURLCTID = "https://test.xahauexplorer.com/explorer/" + XahauTestnetExplorersBithompURLAccount = "https://test.xahauexplorer.com/explorer/" + + XahauTestnetExplorersXRPLFTechnicalName = "XRPLF Technical Explorer" + XahauTestnetExplorersXRPLFTechnicalURLTx = "https://explorer.xahau-test.net/tx/" + XahauTestnetExplorersXRPLFTechnicalURLAccount = "https://explorer.xahau-test.net/" + XahauTestnetExplorersXRPLFTechnicalURLCTID = "https://explorer.xahau-test.net/" + + MainnetRPC = "https://xrplcluster.com" + TestnetRPC = "https://testnet.xrpl-labs.com" + DevnetRPC = "https://s.devnet.rippletest.net:51234" + XahauRPC = "https://xahau.network" + XahauTestnetRPC = "https://xahau-test.net/" + + MainnetDefinitions = "default" + TestnetDefinitions = "default" + DevnetDefinitions = "default" + XahauDefinitions = "xahau" + XahauTestnetDefinitions = "xahau" + + MainnetIconSquare = "data:image/png;base64,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" + MainnetIconAsset = "data:image/png;base64,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" + TestnetIconSquare = "data:image/png;base64,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" + TestnetIconAsset = "data:image/png;base64,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" + DevnetIconSquare = "data:image/png;base64,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" + DevnetIconAsset = "data:image/png;base64,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" + XahauIconSquare = "data:image/png;base64,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" + XahauIconAsset = "data:image/png;base64,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" + XahauTestnetIconSquare = "data:image/png;base64,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" + XahauTestnetIconAsset = "data:image/png;base64,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" +) + +type RailsResponse map[string]Rail type Rail struct { - ChainID int `json:"chain_id,omitempty"` - Color string `json:"color,omitempty"` - Name string `json:"name,omitempty"` - IsLivenet bool `json:"is_livenet,omitempty"` - NativeAsset string `json:"native_asset,omitempty"` - Faucet string `json:"faucet,omitempty"` - Endpoints []RailsEndpoint `json:"endpoints,omitempty"` - Explorers []RailsExplorer `json:"explorers,omitempty"` - RPC string `json:"rpc,omitempty"` - Definitions string `json:"definitions,omitempty"` - Icons RailsIcon `json:"icons,omitempty"` + ChainID int `json:"chain_id"` + Color string `json:"color"` + Name string `json:"name"` + IsLivenet bool `json:"is_livenet"` + NativeAsset string `json:"native_asset"` + Faucet string `json:"faucet"` + XpopEndpoints []XpopEndpoints `json:"xpop_endpoints,omitempty"` + Endpoints []RailsEndpoint `json:"endpoints"` + Explorers []RailsExplorer `json:"explorers"` + RPC string `json:"rpc,omitempty"` + Definitions string `json:"definitions,omitempty"` + Icons RailsIcon `json:"icons"` } type RailsEndpoint struct { - Name string `json:"name,omitempty"` - Url string `json:"url,omitempty"` + Name string `json:"name"` + Url string `json:"url"` } type RailsExplorer struct { - Name string `json:"name,omitempty"` - URLTx string `json:"url_tx,omitempty"` - URLCTID string `json:"url_ctid,omitempty"` - URLAccount string `json:"url_account,omitempty"` - _URLAccount string `json:"_url_account,omitempty"` + Name string `json:"name"` + URLTx string `json:"url_tx"` + URLCTID string `json:"url_ctid,omitempty"` + URLAccount string `json:"url_account,omitempty"` + URLAccountNonExp string `json:"_url_account,omitempty"` } type RailsIcon struct { - IconSquare string `json:"icon_square,omitempty"` - IconAsset string `json:"icon_asset,omitempty"` + IconSquare string `json:"icon_square"` + IconAsset string `json:"icon_asset"` } + +type XpopEndpoints string diff --git a/xumm/models/rates_currency_reponse.go b/xumm/models/rates_currency_reponse.go index c8b64ac..59197d3 100644 --- a/xumm/models/rates_currency_reponse.go +++ b/xumm/models/rates_currency_reponse.go @@ -13,5 +13,5 @@ type Meta struct { type Currency struct { En string `json:"en"` Code string `json:"code"` - Symbol string `json:"symbol"` + Symbol string `json:"symbol,omitempty"` } diff --git a/xumm/models/user_token_validity.go b/xumm/models/user_token_validity.go index aa4ce4c..fd0f48c 100644 --- a/xumm/models/user_token_validity.go +++ b/xumm/models/user_token_validity.go @@ -3,8 +3,8 @@ package models type UserTokenValidity struct { UserToken string `json:"user_token"` Active bool `json:"active"` - Issued int64 `json:"issued"` - Expires int64 `json:"expires"` + Issued int64 `json:"issued,omitempty"` + Expires int64 `json:"expires,omitempty"` } type UserTokenResponse struct { diff --git a/xumm/payload/delete_payload_test.go b/xumm/payload/delete_payload_test.go index 167be63..ecfe1cc 100644 --- a/xumm/payload/delete_payload_test.go +++ b/xumm/payload/delete_payload_test.go @@ -123,9 +123,6 @@ func TestCancelPayloadByUuid(t *testing.T) { AppOpened: false, ReturnURLApp: "", ReturnURLWeb: "", - CustomIdentifier: "some_identifier_1337", - CustomBlob: anyjson.AnyJson{}, - CustomInstruction: "Hey ❤️ ...", }, }, statusCode: 200, diff --git a/xumm/payload/get_payload_custom_id_test.go b/xumm/payload/get_payload_custom_id_test.go index 7c81309..93e4cb2 100644 --- a/xumm/payload/get_payload_custom_id_test.go +++ b/xumm/payload/get_payload_custom_id_test.go @@ -8,7 +8,6 @@ import ( "testing" "github.com/stretchr/testify/assert" - anyjson "github.com/xyield/xumm-go-client/utils/json" testutils "github.com/xyield/xumm-go-client/utils/test-utils" "github.com/xyield/xumm-go-client/xumm" "github.com/xyield/xumm-go-client/xumm/models" @@ -59,9 +58,8 @@ func TestGetPayloadCustomId(t *testing.T) { TxType: "SignIn", TxDestination: "", TxDestinationTag: 0, - RequestJSON: anyjson.AnyJson{ - "TransactionType": "SignIn", - "SignIn": true, + RequestJSON: models.PayloadRequestJsonObject{ + TransactionType: "SignIn", }, Origintype: "test", Signmethod: "test", diff --git a/xumm/payload/get_payload_uuid_test.go b/xumm/payload/get_payload_uuid_test.go index 94f6e5c..e1780ba 100644 --- a/xumm/payload/get_payload_uuid_test.go +++ b/xumm/payload/get_payload_uuid_test.go @@ -8,7 +8,6 @@ import ( "testing" "github.com/stretchr/testify/assert" - anyjson "github.com/xyield/xumm-go-client/utils/json" testutils "github.com/xyield/xumm-go-client/utils/test-utils" "github.com/xyield/xumm-go-client/xumm" "github.com/xyield/xumm-go-client/xumm/models" @@ -59,9 +58,8 @@ func TestGetPayloadUuid(t *testing.T) { TxType: "SignIn", TxDestination: "", TxDestinationTag: 0, - RequestJSON: anyjson.AnyJson{ - "TransactionType": "SignIn", - "SignIn": true, + RequestJSON: models.PayloadRequestJsonObject{ + TransactionType: "SignIn", }, Origintype: "test", Signmethod: "test", diff --git a/xumm/payload/subscribe_payload_test.go b/xumm/payload/subscribe_payload_test.go index 0e9b79f..ef799ae 100644 --- a/xumm/payload/subscribe_payload_test.go +++ b/xumm/payload/subscribe_payload_test.go @@ -70,9 +70,8 @@ func TestSubscribe(t *testing.T) { TxType: "SignIn", TxDestination: "", TxDestinationTag: 0, - RequestJSON: anyjson.AnyJson{ - "TransactionType": "SignIn", - "SignIn": true, + RequestJSON: models.PayloadRequestJsonObject{ + TransactionType: "SignIn", }, Origintype: "test", Signmethod: "test", @@ -289,9 +288,8 @@ func TestCreateAndSubscribe(t *testing.T) { TxType: "SignIn", TxDestination: "", TxDestinationTag: 0, - RequestJSON: anyjson.AnyJson{ - "TransactionType": "SignIn", - "SignIn": true, + RequestJSON: models.PayloadRequestJsonObject{ + TransactionType: "SignIn", }, Origintype: "test", Signmethod: "test",