restucturization of recipients payment methods

.gitignore

@@ -6,5 +6,6 @@ pubspec.lock
 analysis_options.yaml
 devtools_options.yaml
 untranslated.txt
+generate_protos.sh
 update_dep.sh
 .vscode/

.woodpecker/bump_version.yml

@@ -1,33 +0,0 @@
-depends_on:
-  - bff
-  - billing_fees
-  - chain_gateway
-  - db
-  - frontend
-  - fx_ingestor
-  - fx_oracle
-  - ledger
-  - nats
-  - notification
-  - payments_orchestrator
-
-when:
-  event: push
-  branch: main
-
-steps:
-  - name: bump-version
-    image: alpine:latest
-    environment:
-      GIT_AUTHOR_NAME: woodpecker
-      GIT_AUTHOR_EMAIL: ci@sendico.io
-      GIT_COMMITTER_NAME: woodpecker
-      GIT_COMMITTER_EMAIL: ci@sendico.io
-    commands:
-      - set -euo pipefail
-      - apk add --no-cache git
-      # make sure git knows who commits
-      - git config user.name "$GIT_AUTHOR_NAME"
-      - git config user.email "$GIT_AUTHOR_EMAIL"
-      # run your script (must do commit + push)
-      - sh ci/scripts/common/bump_version.sh

.woodpecker/chain_gateway.yml

@@ -1,11 +1,11 @@
 matrix:
   include:
-    - CHAIN_GATEWAY_IMAGE_PATH: chain/gateway
+    - CHAIN_GATEWAY_IMAGE_PATH: gateway/chain
       CHAIN_GATEWAY_DOCKERFILE: ci/prod/compose/chain_gateway.dockerfile
       CHAIN_GATEWAY_MONGO_SECRET_PATH: sendico/db
-      CHAIN_GATEWAY_RPC_SECRET_PATH: sendico/chain/gateway
+      CHAIN_GATEWAY_RPC_SECRET_PATH: sendico/gateway/chain
-      CHAIN_GATEWAY_WALLET_SECRET_PATH: sendico/chain/gateway/wallet
+      CHAIN_GATEWAY_WALLET_SECRET_PATH: sendico/gateway/chain/wallet
-      CHAIN_GATEWAY_VAULT_SECRET_PATH: sendico/chain/gateway/vault
+      CHAIN_GATEWAY_VAULT_SECRET_PATH: sendico/gateway/chain/vault
       CHAIN_GATEWAY_ENV: prod
 
 when:

api/billing/fees/go.mod

@@ -25,7 +25,7 @@ require (
 	github.com/go-chi/chi/v5 v5.2.3 // indirect
 	github.com/golang/snappy v1.0.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/klauspost/compress v1.18.1 // indirect
+	github.com/klauspost/compress v1.18.2 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
@@ -49,6 +49,6 @@ require (
 	golang.org/x/sync v0.18.0 // indirect
 	golang.org/x/sys v0.38.0 // indirect
 	golang.org/x/text v0.31.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 // indirect
 	google.golang.org/protobuf v1.36.10
 )

api/billing/fees/go.sum

@@ -59,8 +59,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/klauspost/compress v1.18.1 h1:bcSGx7UbpBqMChDtsF28Lw6v/G94LPrrbMbdC3JH2co=
+github.com/klauspost/compress v1.18.2 h1:iiPHWW0YrcFgpBYhsA6D1+fqHssJscY/Tm/y2Uqnapk=
-github.com/klauspost/compress v1.18.1/go.mod h1:ZQFFVG+MdnR0P+l6wpXgIL4NTtwiKIdBnrBd8Nrxr+0=
+github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@@ -212,8 +212,8 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
 gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846 h1:Wgl1rcDNThT+Zn47YyCXOXyX/COgMTIdhJ717F0l4xk=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 h1:gRkg/vSppuSQoDjxyiGfN4Upv/h/DQmIR10ZU8dh4Ww=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
 google.golang.org/grpc v1.77.0 h1:wVVY6/8cGA6vvffn+wWK5ToddbgdU3d8MNENr4evgXM=
 google.golang.org/grpc v1.77.0/go.mod h1:z0BY1iVj0q8E1uSQCjL9cppRj+gnZjzDnzV0dHhrNig=
 google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=

api/chain/gateway/client/fake.go

@@ -1,83 +0,0 @@
-package client
-
-import (
-	"context"
-
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
-)
-
-// Fake implements Client for tests.
-type Fake struct {
-	CreateManagedWalletFn func(ctx context.Context, req *gatewayv1.CreateManagedWalletRequest) (*gatewayv1.CreateManagedWalletResponse, error)
-	GetManagedWalletFn    func(ctx context.Context, req *gatewayv1.GetManagedWalletRequest) (*gatewayv1.GetManagedWalletResponse, error)
-	ListManagedWalletsFn  func(ctx context.Context, req *gatewayv1.ListManagedWalletsRequest) (*gatewayv1.ListManagedWalletsResponse, error)
-	GetWalletBalanceFn    func(ctx context.Context, req *gatewayv1.GetWalletBalanceRequest) (*gatewayv1.GetWalletBalanceResponse, error)
-	SubmitTransferFn      func(ctx context.Context, req *gatewayv1.SubmitTransferRequest) (*gatewayv1.SubmitTransferResponse, error)
-	GetTransferFn         func(ctx context.Context, req *gatewayv1.GetTransferRequest) (*gatewayv1.GetTransferResponse, error)
-	ListTransfersFn       func(ctx context.Context, req *gatewayv1.ListTransfersRequest) (*gatewayv1.ListTransfersResponse, error)
-	EstimateTransferFeeFn func(ctx context.Context, req *gatewayv1.EstimateTransferFeeRequest) (*gatewayv1.EstimateTransferFeeResponse, error)
-	CloseFn               func() error
-}
-
-func (f *Fake) CreateManagedWallet(ctx context.Context, req *gatewayv1.CreateManagedWalletRequest) (*gatewayv1.CreateManagedWalletResponse, error) {
-	if f.CreateManagedWalletFn != nil {
-		return f.CreateManagedWalletFn(ctx, req)
-	}
-	return &gatewayv1.CreateManagedWalletResponse{}, nil
-}
-
-func (f *Fake) GetManagedWallet(ctx context.Context, req *gatewayv1.GetManagedWalletRequest) (*gatewayv1.GetManagedWalletResponse, error) {
-	if f.GetManagedWalletFn != nil {
-		return f.GetManagedWalletFn(ctx, req)
-	}
-	return &gatewayv1.GetManagedWalletResponse{}, nil
-}
-
-func (f *Fake) ListManagedWallets(ctx context.Context, req *gatewayv1.ListManagedWalletsRequest) (*gatewayv1.ListManagedWalletsResponse, error) {
-	if f.ListManagedWalletsFn != nil {
-		return f.ListManagedWalletsFn(ctx, req)
-	}
-	return &gatewayv1.ListManagedWalletsResponse{}, nil
-}
-
-func (f *Fake) GetWalletBalance(ctx context.Context, req *gatewayv1.GetWalletBalanceRequest) (*gatewayv1.GetWalletBalanceResponse, error) {
-	if f.GetWalletBalanceFn != nil {
-		return f.GetWalletBalanceFn(ctx, req)
-	}
-	return &gatewayv1.GetWalletBalanceResponse{}, nil
-}
-
-func (f *Fake) SubmitTransfer(ctx context.Context, req *gatewayv1.SubmitTransferRequest) (*gatewayv1.SubmitTransferResponse, error) {
-	if f.SubmitTransferFn != nil {
-		return f.SubmitTransferFn(ctx, req)
-	}
-	return &gatewayv1.SubmitTransferResponse{}, nil
-}
-
-func (f *Fake) GetTransfer(ctx context.Context, req *gatewayv1.GetTransferRequest) (*gatewayv1.GetTransferResponse, error) {
-	if f.GetTransferFn != nil {
-		return f.GetTransferFn(ctx, req)
-	}
-	return &gatewayv1.GetTransferResponse{}, nil
-}
-
-func (f *Fake) ListTransfers(ctx context.Context, req *gatewayv1.ListTransfersRequest) (*gatewayv1.ListTransfersResponse, error) {
-	if f.ListTransfersFn != nil {
-		return f.ListTransfersFn(ctx, req)
-	}
-	return &gatewayv1.ListTransfersResponse{}, nil
-}
-
-func (f *Fake) EstimateTransferFee(ctx context.Context, req *gatewayv1.EstimateTransferFeeRequest) (*gatewayv1.EstimateTransferFeeResponse, error) {
-	if f.EstimateTransferFeeFn != nil {
-		return f.EstimateTransferFeeFn(ctx, req)
-	}
-	return &gatewayv1.EstimateTransferFeeResponse{}, nil
-}
-
-func (f *Fake) Close() error {
-	if f.CloseFn != nil {
-		return f.CloseFn()
-	}
-	return nil
-}

api/fx/ingestor/go.mod

@@ -25,7 +25,7 @@ require (
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/golang/snappy v1.0.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/klauspost/compress v1.18.1 // indirect
+	github.com/klauspost/compress v1.18.2 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
@@ -49,7 +49,7 @@ require (
 	golang.org/x/sync v0.18.0 // indirect
 	golang.org/x/sys v0.38.0 // indirect
 	golang.org/x/text v0.31.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 // indirect
 	google.golang.org/grpc v1.77.0 // indirect
 	google.golang.org/protobuf v1.36.10 // indirect
 )

api/fx/ingestor/go.sum

@@ -59,8 +59,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/klauspost/compress v1.18.1 h1:bcSGx7UbpBqMChDtsF28Lw6v/G94LPrrbMbdC3JH2co=
+github.com/klauspost/compress v1.18.2 h1:iiPHWW0YrcFgpBYhsA6D1+fqHssJscY/Tm/y2Uqnapk=
-github.com/klauspost/compress v1.18.1/go.mod h1:ZQFFVG+MdnR0P+l6wpXgIL4NTtwiKIdBnrBd8Nrxr+0=
+github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@@ -212,8 +212,8 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
 gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846 h1:Wgl1rcDNThT+Zn47YyCXOXyX/COgMTIdhJ717F0l4xk=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 h1:gRkg/vSppuSQoDjxyiGfN4Upv/h/DQmIR10ZU8dh4Ww=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
 google.golang.org/grpc v1.77.0 h1:wVVY6/8cGA6vvffn+wWK5ToddbgdU3d8MNENr4evgXM=
 google.golang.org/grpc v1.77.0/go.mod h1:z0BY1iVj0q8E1uSQCjL9cppRj+gnZjzDnzV0dHhrNig=
 google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=

api/fx/oracle/go.mod

@@ -27,7 +27,7 @@ require (
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/go-chi/chi/v5 v5.2.3 // indirect
 	github.com/golang/snappy v1.0.0 // indirect
-	github.com/klauspost/compress v1.18.1 // indirect
+	github.com/klauspost/compress v1.18.2 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
@@ -50,5 +50,5 @@ require (
 	golang.org/x/sync v0.18.0 // indirect
 	golang.org/x/sys v0.38.0 // indirect
 	golang.org/x/text v0.31.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 // indirect
 )

api/fx/oracle/go.sum

@@ -59,8 +59,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/klauspost/compress v1.18.1 h1:bcSGx7UbpBqMChDtsF28Lw6v/G94LPrrbMbdC3JH2co=
+github.com/klauspost/compress v1.18.2 h1:iiPHWW0YrcFgpBYhsA6D1+fqHssJscY/Tm/y2Uqnapk=
-github.com/klauspost/compress v1.18.1/go.mod h1:ZQFFVG+MdnR0P+l6wpXgIL4NTtwiKIdBnrBd8Nrxr+0=
+github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@@ -212,8 +212,8 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
 gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846 h1:Wgl1rcDNThT+Zn47YyCXOXyX/COgMTIdhJ717F0l4xk=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 h1:gRkg/vSppuSQoDjxyiGfN4Upv/h/DQmIR10ZU8dh4Ww=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
 google.golang.org/grpc v1.77.0 h1:wVVY6/8cGA6vvffn+wWK5ToddbgdU3d8MNENr4evgXM=
 google.golang.org/grpc v1.77.0/go.mod h1:z0BY1iVj0q8E1uSQCjL9cppRj+gnZjzDnzV0dHhrNig=
 google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=

api/fx/storage/go.mod

@@ -17,7 +17,7 @@ require (
 	github.com/casbin/mongodb-adapter/v3 v3.7.0 // indirect
 	github.com/golang/snappy v1.0.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/klauspost/compress v1.18.1 // indirect
+	github.com/klauspost/compress v1.18.2 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/montanaflynn/stats v0.7.1 // indirect
 	github.com/xdg-go/pbkdf2 v1.0.0 // indirect

api/fx/storage/go.sum

@@ -51,8 +51,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/klauspost/compress v1.18.1 h1:bcSGx7UbpBqMChDtsF28Lw6v/G94LPrrbMbdC3JH2co=
+github.com/klauspost/compress v1.18.2 h1:iiPHWW0YrcFgpBYhsA6D1+fqHssJscY/Tm/y2Uqnapk=
-github.com/klauspost/compress v1.18.1/go.mod h1:ZQFFVG+MdnR0P+l6wpXgIL4NTtwiKIdBnrBd8Nrxr+0=
+github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
 github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54 h1:mFWunSatvkQQDhpdyuFAYwyAan3hzCuma+Pz8sqvOfg=
 github.com/lufia/plan9stats v0.0.0-20250827001030-24949be3fa54/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
 github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=

api/gateway/chain/.air.toml

@@ -4,11 +4,11 @@ root = "./../.."
 tmp_dir = "tmp"
 
 [build]
-cmd = "go build -o app -ldflags \"-X 'github.com/tech/sendico/chain/gateway/internal/appversion.BuildUser=$(whoami)' -X 'github.com/tech/sendico/chain/gateway/internal/appversion.Version=$APP_V' -X 'github.com/tech/sendico/chain/gateway/internal/appversion.Branch=$BUILD_BRANCH' -X 'github.com/tech/sendico/chain/gateway/internal/appversion.Revision=$GIT_REV' -X 'github.com/tech/sendico/chain/gateway/internal/appversion.BuildDate=$(date)'\""
+cmd = "go build -o app -ldflags \"-X 'github.com/tech/sendico/gateway/chain/internal/appversion.BuildUser=$(whoami)' -X 'github.com/tech/sendico/gateway/chain/internal/appversion.Version=$APP_V' -X 'github.com/tech/sendico/gateway/chain/internal/appversion.Branch=$BUILD_BRANCH' -X 'github.com/tech/sendico/gateway/chain/internal/appversion.Revision=$GIT_REV' -X 'github.com/tech/sendico/gateway/chain/internal/appversion.BuildDate=$(date)'\""
 bin = "./app"
 full_bin = "./app --debug --config.file=config.yml"
 include_ext = ["go", "yaml", "yml"]
-exclude_dir = ["chain/gateway/tmp", "pkg/.git", "chain/gateway/env"]
+exclude_dir = ["gateway/chain/tmp", "pkg/.git", "gateway/chain/env"]
 exclude_regex = ["_test\\.go"]
 exclude_unchanged = true
 follow_symlink = true

api/gateway/chain/client/client.go

@@ -8,7 +8,7 @@ import (
 	"time"
 
 	"github.com/tech/sendico/pkg/merrors"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/credentials/insecure"
@@ -16,26 +16,26 @@ import (
 
 // Client exposes typed helpers around the chain gateway gRPC API.
 type Client interface {
-	CreateManagedWallet(ctx context.Context, req *gatewayv1.CreateManagedWalletRequest) (*gatewayv1.CreateManagedWalletResponse, error)
+	CreateManagedWallet(ctx context.Context, req *chainv1.CreateManagedWalletRequest) (*chainv1.CreateManagedWalletResponse, error)
-	GetManagedWallet(ctx context.Context, req *gatewayv1.GetManagedWalletRequest) (*gatewayv1.GetManagedWalletResponse, error)
+	GetManagedWallet(ctx context.Context, req *chainv1.GetManagedWalletRequest) (*chainv1.GetManagedWalletResponse, error)
-	ListManagedWallets(ctx context.Context, req *gatewayv1.ListManagedWalletsRequest) (*gatewayv1.ListManagedWalletsResponse, error)
+	ListManagedWallets(ctx context.Context, req *chainv1.ListManagedWalletsRequest) (*chainv1.ListManagedWalletsResponse, error)
-	GetWalletBalance(ctx context.Context, req *gatewayv1.GetWalletBalanceRequest) (*gatewayv1.GetWalletBalanceResponse, error)
+	GetWalletBalance(ctx context.Context, req *chainv1.GetWalletBalanceRequest) (*chainv1.GetWalletBalanceResponse, error)
-	SubmitTransfer(ctx context.Context, req *gatewayv1.SubmitTransferRequest) (*gatewayv1.SubmitTransferResponse, error)
+	SubmitTransfer(ctx context.Context, req *chainv1.SubmitTransferRequest) (*chainv1.SubmitTransferResponse, error)
-	GetTransfer(ctx context.Context, req *gatewayv1.GetTransferRequest) (*gatewayv1.GetTransferResponse, error)
+	GetTransfer(ctx context.Context, req *chainv1.GetTransferRequest) (*chainv1.GetTransferResponse, error)
-	ListTransfers(ctx context.Context, req *gatewayv1.ListTransfersRequest) (*gatewayv1.ListTransfersResponse, error)
+	ListTransfers(ctx context.Context, req *chainv1.ListTransfersRequest) (*chainv1.ListTransfersResponse, error)
-	EstimateTransferFee(ctx context.Context, req *gatewayv1.EstimateTransferFeeRequest) (*gatewayv1.EstimateTransferFeeResponse, error)
+	EstimateTransferFee(ctx context.Context, req *chainv1.EstimateTransferFeeRequest) (*chainv1.EstimateTransferFeeResponse, error)
 	Close() error
 }
 
 type grpcGatewayClient interface {
-	CreateManagedWallet(ctx context.Context, in *gatewayv1.CreateManagedWalletRequest, opts ...grpc.CallOption) (*gatewayv1.CreateManagedWalletResponse, error)
+	CreateManagedWallet(ctx context.Context, in *chainv1.CreateManagedWalletRequest, opts ...grpc.CallOption) (*chainv1.CreateManagedWalletResponse, error)
-	GetManagedWallet(ctx context.Context, in *gatewayv1.GetManagedWalletRequest, opts ...grpc.CallOption) (*gatewayv1.GetManagedWalletResponse, error)
+	GetManagedWallet(ctx context.Context, in *chainv1.GetManagedWalletRequest, opts ...grpc.CallOption) (*chainv1.GetManagedWalletResponse, error)
-	ListManagedWallets(ctx context.Context, in *gatewayv1.ListManagedWalletsRequest, opts ...grpc.CallOption) (*gatewayv1.ListManagedWalletsResponse, error)
+	ListManagedWallets(ctx context.Context, in *chainv1.ListManagedWalletsRequest, opts ...grpc.CallOption) (*chainv1.ListManagedWalletsResponse, error)
-	GetWalletBalance(ctx context.Context, in *gatewayv1.GetWalletBalanceRequest, opts ...grpc.CallOption) (*gatewayv1.GetWalletBalanceResponse, error)
+	GetWalletBalance(ctx context.Context, in *chainv1.GetWalletBalanceRequest, opts ...grpc.CallOption) (*chainv1.GetWalletBalanceResponse, error)
-	SubmitTransfer(ctx context.Context, in *gatewayv1.SubmitTransferRequest, opts ...grpc.CallOption) (*gatewayv1.SubmitTransferResponse, error)
+	SubmitTransfer(ctx context.Context, in *chainv1.SubmitTransferRequest, opts ...grpc.CallOption) (*chainv1.SubmitTransferResponse, error)
-	GetTransfer(ctx context.Context, in *gatewayv1.GetTransferRequest, opts ...grpc.CallOption) (*gatewayv1.GetTransferResponse, error)
+	GetTransfer(ctx context.Context, in *chainv1.GetTransferRequest, opts ...grpc.CallOption) (*chainv1.GetTransferResponse, error)
-	ListTransfers(ctx context.Context, in *gatewayv1.ListTransfersRequest, opts ...grpc.CallOption) (*gatewayv1.ListTransfersResponse, error)
+	ListTransfers(ctx context.Context, in *chainv1.ListTransfersRequest, opts ...grpc.CallOption) (*chainv1.ListTransfersResponse, error)
-	EstimateTransferFee(ctx context.Context, in *gatewayv1.EstimateTransferFeeRequest, opts ...grpc.CallOption) (*gatewayv1.EstimateTransferFeeResponse, error)
+	EstimateTransferFee(ctx context.Context, in *chainv1.EstimateTransferFeeRequest, opts ...grpc.CallOption) (*chainv1.EstimateTransferFeeResponse, error)
 }
 
 type chainGatewayClient struct {
@@ -71,7 +71,7 @@ func New(ctx context.Context, cfg Config, opts ...grpc.DialOption) (Client, erro
 	return &chainGatewayClient{
 		cfg:    cfg,
 		conn:   conn,
-		client: gatewayv1.NewChainGatewayServiceClient(conn),
+		client: chainv1.NewChainGatewayServiceClient(conn),
 	}, nil
 }
 
@@ -91,49 +91,49 @@ func (c *chainGatewayClient) Close() error {
 	return nil
 }
 
-func (c *chainGatewayClient) CreateManagedWallet(ctx context.Context, req *gatewayv1.CreateManagedWalletRequest) (*gatewayv1.CreateManagedWalletResponse, error) {
+func (c *chainGatewayClient) CreateManagedWallet(ctx context.Context, req *chainv1.CreateManagedWalletRequest) (*chainv1.CreateManagedWalletResponse, error) {
 	ctx, cancel := c.callContext(ctx)
 	defer cancel()
 	return c.client.CreateManagedWallet(ctx, req)
 }
 
-func (c *chainGatewayClient) GetManagedWallet(ctx context.Context, req *gatewayv1.GetManagedWalletRequest) (*gatewayv1.GetManagedWalletResponse, error) {
+func (c *chainGatewayClient) GetManagedWallet(ctx context.Context, req *chainv1.GetManagedWalletRequest) (*chainv1.GetManagedWalletResponse, error) {
 	ctx, cancel := c.callContext(ctx)
 	defer cancel()
 	return c.client.GetManagedWallet(ctx, req)
 }
 
-func (c *chainGatewayClient) ListManagedWallets(ctx context.Context, req *gatewayv1.ListManagedWalletsRequest) (*gatewayv1.ListManagedWalletsResponse, error) {
+func (c *chainGatewayClient) ListManagedWallets(ctx context.Context, req *chainv1.ListManagedWalletsRequest) (*chainv1.ListManagedWalletsResponse, error) {
 	ctx, cancel := c.callContext(ctx)
 	defer cancel()
 	return c.client.ListManagedWallets(ctx, req)
 }
 
-func (c *chainGatewayClient) GetWalletBalance(ctx context.Context, req *gatewayv1.GetWalletBalanceRequest) (*gatewayv1.GetWalletBalanceResponse, error) {
+func (c *chainGatewayClient) GetWalletBalance(ctx context.Context, req *chainv1.GetWalletBalanceRequest) (*chainv1.GetWalletBalanceResponse, error) {
 	ctx, cancel := c.callContext(ctx)
 	defer cancel()
 	return c.client.GetWalletBalance(ctx, req)
 }
 
-func (c *chainGatewayClient) SubmitTransfer(ctx context.Context, req *gatewayv1.SubmitTransferRequest) (*gatewayv1.SubmitTransferResponse, error) {
+func (c *chainGatewayClient) SubmitTransfer(ctx context.Context, req *chainv1.SubmitTransferRequest) (*chainv1.SubmitTransferResponse, error) {
 	ctx, cancel := c.callContext(ctx)
 	defer cancel()
 	return c.client.SubmitTransfer(ctx, req)
 }
 
-func (c *chainGatewayClient) GetTransfer(ctx context.Context, req *gatewayv1.GetTransferRequest) (*gatewayv1.GetTransferResponse, error) {
+func (c *chainGatewayClient) GetTransfer(ctx context.Context, req *chainv1.GetTransferRequest) (*chainv1.GetTransferResponse, error) {
 	ctx, cancel := c.callContext(ctx)
 	defer cancel()
 	return c.client.GetTransfer(ctx, req)
 }
 
-func (c *chainGatewayClient) ListTransfers(ctx context.Context, req *gatewayv1.ListTransfersRequest) (*gatewayv1.ListTransfersResponse, error) {
+func (c *chainGatewayClient) ListTransfers(ctx context.Context, req *chainv1.ListTransfersRequest) (*chainv1.ListTransfersResponse, error) {
 	ctx, cancel := c.callContext(ctx)
 	defer cancel()
 	return c.client.ListTransfers(ctx, req)
 }
 
-func (c *chainGatewayClient) EstimateTransferFee(ctx context.Context, req *gatewayv1.EstimateTransferFeeRequest) (*gatewayv1.EstimateTransferFeeResponse, error) {
+func (c *chainGatewayClient) EstimateTransferFee(ctx context.Context, req *chainv1.EstimateTransferFeeRequest) (*chainv1.EstimateTransferFeeResponse, error) {
 	ctx, cancel := c.callContext(ctx)
 	defer cancel()
 	return c.client.EstimateTransferFee(ctx, req)

api/gateway/chain/client/fake.go

@@ -0,0 +1,83 @@
+package client
+
+import (
+	"context"
+
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
+)
+
+// Fake implements Client for tests.
+type Fake struct {
+	CreateManagedWalletFn func(ctx context.Context, req *chainv1.CreateManagedWalletRequest) (*chainv1.CreateManagedWalletResponse, error)
+	GetManagedWalletFn    func(ctx context.Context, req *chainv1.GetManagedWalletRequest) (*chainv1.GetManagedWalletResponse, error)
+	ListManagedWalletsFn  func(ctx context.Context, req *chainv1.ListManagedWalletsRequest) (*chainv1.ListManagedWalletsResponse, error)
+	GetWalletBalanceFn    func(ctx context.Context, req *chainv1.GetWalletBalanceRequest) (*chainv1.GetWalletBalanceResponse, error)
+	SubmitTransferFn      func(ctx context.Context, req *chainv1.SubmitTransferRequest) (*chainv1.SubmitTransferResponse, error)
+	GetTransferFn         func(ctx context.Context, req *chainv1.GetTransferRequest) (*chainv1.GetTransferResponse, error)
+	ListTransfersFn       func(ctx context.Context, req *chainv1.ListTransfersRequest) (*chainv1.ListTransfersResponse, error)
+	EstimateTransferFeeFn func(ctx context.Context, req *chainv1.EstimateTransferFeeRequest) (*chainv1.EstimateTransferFeeResponse, error)
+	CloseFn               func() error
+}
+
+func (f *Fake) CreateManagedWallet(ctx context.Context, req *chainv1.CreateManagedWalletRequest) (*chainv1.CreateManagedWalletResponse, error) {
+	if f.CreateManagedWalletFn != nil {
+		return f.CreateManagedWalletFn(ctx, req)
+	}
+	return &chainv1.CreateManagedWalletResponse{}, nil
+}
+
+func (f *Fake) GetManagedWallet(ctx context.Context, req *chainv1.GetManagedWalletRequest) (*chainv1.GetManagedWalletResponse, error) {
+	if f.GetManagedWalletFn != nil {
+		return f.GetManagedWalletFn(ctx, req)
+	}
+	return &chainv1.GetManagedWalletResponse{}, nil
+}
+
+func (f *Fake) ListManagedWallets(ctx context.Context, req *chainv1.ListManagedWalletsRequest) (*chainv1.ListManagedWalletsResponse, error) {
+	if f.ListManagedWalletsFn != nil {
+		return f.ListManagedWalletsFn(ctx, req)
+	}
+	return &chainv1.ListManagedWalletsResponse{}, nil
+}
+
+func (f *Fake) GetWalletBalance(ctx context.Context, req *chainv1.GetWalletBalanceRequest) (*chainv1.GetWalletBalanceResponse, error) {
+	if f.GetWalletBalanceFn != nil {
+		return f.GetWalletBalanceFn(ctx, req)
+	}
+	return &chainv1.GetWalletBalanceResponse{}, nil
+}
+
+func (f *Fake) SubmitTransfer(ctx context.Context, req *chainv1.SubmitTransferRequest) (*chainv1.SubmitTransferResponse, error) {
+	if f.SubmitTransferFn != nil {
+		return f.SubmitTransferFn(ctx, req)
+	}
+	return &chainv1.SubmitTransferResponse{}, nil
+}
+
+func (f *Fake) GetTransfer(ctx context.Context, req *chainv1.GetTransferRequest) (*chainv1.GetTransferResponse, error) {
+	if f.GetTransferFn != nil {
+		return f.GetTransferFn(ctx, req)
+	}
+	return &chainv1.GetTransferResponse{}, nil
+}
+
+func (f *Fake) ListTransfers(ctx context.Context, req *chainv1.ListTransfersRequest) (*chainv1.ListTransfersResponse, error) {
+	if f.ListTransfersFn != nil {
+		return f.ListTransfersFn(ctx, req)
+	}
+	return &chainv1.ListTransfersResponse{}, nil
+}
+
+func (f *Fake) EstimateTransferFee(ctx context.Context, req *chainv1.EstimateTransferFeeRequest) (*chainv1.EstimateTransferFeeResponse, error) {
+	if f.EstimateTransferFeeFn != nil {
+		return f.EstimateTransferFeeFn(ctx, req)
+	}
+	return &chainv1.EstimateTransferFeeResponse{}, nil
+}
+
+func (f *Fake) Close() error {
+	if f.CloseFn != nil {
+		return f.CloseFn()
+	}
+	return nil
+}

api/gateway/chain/config.yml

@@ -54,4 +54,4 @@ key_management:
     token_env: VAULT_TOKEN
     namespace: ""
     mount_path: kv
-    key_prefix: chain/gateway/wallets
+    key_prefix: gateway/chain/wallets

api/gateway/chain/go.mod

@@ -1,4 +1,4 @@
-module github.com/tech/sendico/chain/gateway
+module github.com/tech/sendico/gateway/chain
 
 go 1.25.3
 

api/gateway/chain/internal/keymanager/vault/manager.go

@@ -16,7 +16,7 @@ import (
 	"github.com/hashicorp/vault/api"
 	"go.uber.org/zap"
 
-	"github.com/tech/sendico/chain/gateway/internal/keymanager"
+	"github.com/tech/sendico/gateway/chain/internal/keymanager"
 	"github.com/tech/sendico/pkg/merrors"
 	"github.com/tech/sendico/pkg/mlogger"
 )

api/gateway/chain/internal/server/internal/serverimp.go

@@ -7,12 +7,12 @@ import (
 	"time"
 
 	"github.com/mitchellh/mapstructure"
-	"github.com/tech/sendico/chain/gateway/internal/keymanager"
+	"github.com/tech/sendico/gateway/chain/internal/keymanager"
-	vaultmanager "github.com/tech/sendico/chain/gateway/internal/keymanager/vault"
+	vaultmanager "github.com/tech/sendico/gateway/chain/internal/keymanager/vault"
-	gatewayservice "github.com/tech/sendico/chain/gateway/internal/service/gateway"
+	gatewayservice "github.com/tech/sendico/gateway/chain/internal/service/gateway"
-	gatewayshared "github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	gatewayshared "github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage"
+	"github.com/tech/sendico/gateway/chain/storage"
-	gatewaymongo "github.com/tech/sendico/chain/gateway/storage/mongo"
+	gatewaymongo "github.com/tech/sendico/gateway/chain/storage/mongo"
 	"github.com/tech/sendico/pkg/api/routers"
 	"github.com/tech/sendico/pkg/db"
 	"github.com/tech/sendico/pkg/merrors"

api/gateway/chain/internal/server/server.go

@@ -1,7 +1,7 @@
 package server
 
 import (
-	serverimp "github.com/tech/sendico/chain/gateway/internal/server/internal"
+	serverimp "github.com/tech/sendico/gateway/chain/internal/server/internal"
 	"github.com/tech/sendico/pkg/mlogger"
 	"github.com/tech/sendico/pkg/server"
 )

api/gateway/chain/internal/service/gateway/commands/registry.go

@@ -3,10 +3,10 @@ package commands
 import (
 	"context"
 
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/commands/transfer"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/commands/transfer"
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/commands/wallet"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/commands/wallet"
 	"github.com/tech/sendico/pkg/api/routers/gsresponse"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 )
 
 type Unary[TReq any, TResp any] interface {
@@ -14,15 +14,15 @@ type Unary[TReq any, TResp any] interface {
 }
 
 type Registry struct {
-	CreateManagedWallet Unary[gatewayv1.CreateManagedWalletRequest, gatewayv1.CreateManagedWalletResponse]
+	CreateManagedWallet Unary[chainv1.CreateManagedWalletRequest, chainv1.CreateManagedWalletResponse]
-	GetManagedWallet    Unary[gatewayv1.GetManagedWalletRequest, gatewayv1.GetManagedWalletResponse]
+	GetManagedWallet    Unary[chainv1.GetManagedWalletRequest, chainv1.GetManagedWalletResponse]
-	ListManagedWallets  Unary[gatewayv1.ListManagedWalletsRequest, gatewayv1.ListManagedWalletsResponse]
+	ListManagedWallets  Unary[chainv1.ListManagedWalletsRequest, chainv1.ListManagedWalletsResponse]
-	GetWalletBalance    Unary[gatewayv1.GetWalletBalanceRequest, gatewayv1.GetWalletBalanceResponse]
+	GetWalletBalance    Unary[chainv1.GetWalletBalanceRequest, chainv1.GetWalletBalanceResponse]
 
-	SubmitTransfer   Unary[gatewayv1.SubmitTransferRequest, gatewayv1.SubmitTransferResponse]
+	SubmitTransfer   Unary[chainv1.SubmitTransferRequest, chainv1.SubmitTransferResponse]
-	GetTransfer      Unary[gatewayv1.GetTransferRequest, gatewayv1.GetTransferResponse]
+	GetTransfer      Unary[chainv1.GetTransferRequest, chainv1.GetTransferResponse]
-	ListTransfers    Unary[gatewayv1.ListTransfersRequest, gatewayv1.ListTransfersResponse]
+	ListTransfers    Unary[chainv1.ListTransfersRequest, chainv1.ListTransfersResponse]
-	EstimateTransfer Unary[gatewayv1.EstimateTransferFeeRequest, gatewayv1.EstimateTransferFeeResponse]
+	EstimateTransfer Unary[chainv1.EstimateTransferFeeRequest, chainv1.EstimateTransferFeeResponse]
 }
 
 type RegistryDeps struct {

api/gateway/chain/internal/service/gateway/commands/transfer/convert_fees.go

@@ -4,13 +4,13 @@ import (
 	"strings"
 
 	"github.com/shopspring/decimal"
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/merrors"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 )
 
-func convertFees(fees []*gatewayv1.ServiceFeeBreakdown, currency string) ([]model.ServiceFee, decimal.Decimal, error) {
+func convertFees(fees []*chainv1.ServiceFeeBreakdown, currency string) ([]model.ServiceFee, decimal.Decimal, error) {
 	result := make([]model.ServiceFee, 0, len(fees))
 	sum := decimal.NewFromInt(0)
 	for _, fee := range fees {

api/gateway/chain/internal/service/gateway/commands/transfer/deps.go

@@ -3,8 +3,8 @@ package transfer
 import (
 	"context"
 
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage"
+	"github.com/tech/sendico/gateway/chain/storage"
 	clockpkg "github.com/tech/sendico/pkg/clock"
 	"github.com/tech/sendico/pkg/mlogger"
 )

api/gateway/chain/internal/service/gateway/commands/transfer/destination.go

@@ -4,13 +4,13 @@ import (
 	"context"
 	"strings"
 
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/merrors"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"go.uber.org/zap"
 )
 
-func resolveDestination(ctx context.Context, deps Deps, dest *gatewayv1.TransferDestination, source *model.ManagedWallet) (model.TransferDestination, error) {
+func resolveDestination(ctx context.Context, deps Deps, dest *chainv1.TransferDestination, source *model.ManagedWallet) (model.TransferDestination, error) {
 	if dest == nil {
 		return model.TransferDestination{}, merrors.InvalidArgument("destination is required")
 	}

api/gateway/chain/internal/service/gateway/commands/transfer/destination_address.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"strings"
 
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/merrors"
 )
 

api/gateway/chain/internal/service/gateway/commands/transfer/fee.go

@@ -12,14 +12,14 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/shopspring/decimal"
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/api/routers/gsresponse"
 	"github.com/tech/sendico/pkg/merrors"
 	"github.com/tech/sendico/pkg/mlogger"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
 	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"go.uber.org/zap"
 )
 
@@ -31,67 +31,67 @@ func NewEstimateTransfer(deps Deps) *estimateTransferFeeCommand {
 	return &estimateTransferFeeCommand{deps: deps}
 }
 
-func (c *estimateTransferFeeCommand) Execute(ctx context.Context, req *gatewayv1.EstimateTransferFeeRequest) gsresponse.Responder[gatewayv1.EstimateTransferFeeResponse] {
+func (c *estimateTransferFeeCommand) Execute(ctx context.Context, req *chainv1.EstimateTransferFeeRequest) gsresponse.Responder[chainv1.EstimateTransferFeeResponse] {
 	if err := c.deps.EnsureRepository(ctx); err != nil {
 		c.deps.Logger.Warn("repository unavailable", zap.Error(err))
-		return gsresponse.Unavailable[gatewayv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Unavailable[chainv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 	if req == nil {
 		c.deps.Logger.Warn("nil request")
-		return gsresponse.InvalidArgument[gatewayv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("request is required"))
+		return gsresponse.InvalidArgument[chainv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("request is required"))
 	}
 
 	sourceWalletRef := strings.TrimSpace(req.GetSourceWalletRef())
 	if sourceWalletRef == "" {
 		c.deps.Logger.Warn("source wallet ref missing")
-		return gsresponse.InvalidArgument[gatewayv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("source_wallet_ref is required"))
+		return gsresponse.InvalidArgument[chainv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("source_wallet_ref is required"))
 	}
 	amount := req.GetAmount()
 	if amount == nil || strings.TrimSpace(amount.GetAmount()) == "" || strings.TrimSpace(amount.GetCurrency()) == "" {
 		c.deps.Logger.Warn("amount missing or incomplete")
-		return gsresponse.InvalidArgument[gatewayv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("amount is required"))
+		return gsresponse.InvalidArgument[chainv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("amount is required"))
 	}
 
 	sourceWallet, err := c.deps.Storage.Wallets().Get(ctx, sourceWalletRef)
 	if err != nil {
 		if errors.Is(err, merrors.ErrNoData) {
 			c.deps.Logger.Warn("source wallet not found", zap.String("source_wallet_ref", sourceWalletRef))
-			return gsresponse.NotFound[gatewayv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
+			return gsresponse.NotFound[chainv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
 		}
 		c.deps.Logger.Warn("storage get wallet failed", zap.Error(err), zap.String("source_wallet_ref", sourceWalletRef))
-		return gsresponse.Auto[gatewayv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Auto[chainv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 
 	networkKey := strings.ToLower(strings.TrimSpace(sourceWallet.Network))
 	networkCfg, ok := c.deps.Networks[networkKey]
 	if !ok {
 		c.deps.Logger.Warn("unsupported chain", zap.String("network", networkKey))
-		return gsresponse.InvalidArgument[gatewayv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("unsupported chain for wallet"))
+		return gsresponse.InvalidArgument[chainv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("unsupported chain for wallet"))
 	}
 
 	dest, err := resolveDestination(ctx, c.deps, req.GetDestination(), sourceWallet)
 	if err != nil {
 		if errors.Is(err, merrors.ErrNoData) {
 			c.deps.Logger.Warn("destination not found", zap.String("destination_wallet_ref", req.GetDestination().GetManagedWalletRef()))
-			return gsresponse.NotFound[gatewayv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
+			return gsresponse.NotFound[chainv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
 		}
 		c.deps.Logger.Warn("invalid destination", zap.Error(err))
-		return gsresponse.InvalidArgument[gatewayv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.InvalidArgument[chainv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 
 	destinationAddress, err := destinationAddress(ctx, c.deps, dest)
 	if err != nil {
 		c.deps.Logger.Warn("failed to resolve destination address", zap.Error(err))
-		return gsresponse.InvalidArgument[gatewayv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.InvalidArgument[chainv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 
 	feeMoney, err := estimateNetworkFee(ctx, c.deps.Logger, networkCfg, sourceWallet, destinationAddress, amount)
 	if err != nil {
 		c.deps.Logger.Warn("fee estimation failed", zap.Error(err))
-		return gsresponse.Auto[gatewayv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Auto[chainv1.EstimateTransferFeeResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 
-	resp := &gatewayv1.EstimateTransferFeeResponse{
+	resp := &chainv1.EstimateTransferFeeResponse{
 		NetworkFee:        feeMoney,
 		EstimationContext: "erc20_transfer",
 	}

api/gateway/chain/internal/service/gateway/commands/transfer/get.go

@@ -8,7 +8,7 @@ import (
 	"github.com/tech/sendico/pkg/api/routers/gsresponse"
 	"github.com/tech/sendico/pkg/merrors"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"go.uber.org/zap"
 )
 
@@ -20,28 +20,28 @@ func NewGetTransfer(deps Deps) *getTransferCommand {
 	return &getTransferCommand{deps: deps}
 }
 
-func (c *getTransferCommand) Execute(ctx context.Context, req *gatewayv1.GetTransferRequest) gsresponse.Responder[gatewayv1.GetTransferResponse] {
+func (c *getTransferCommand) Execute(ctx context.Context, req *chainv1.GetTransferRequest) gsresponse.Responder[chainv1.GetTransferResponse] {
 	if err := c.deps.EnsureRepository(ctx); err != nil {
 		c.deps.Logger.Warn("repository unavailable", zap.Error(err))
-		return gsresponse.Unavailable[gatewayv1.GetTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Unavailable[chainv1.GetTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 	if req == nil {
 		c.deps.Logger.Warn("nil request")
-		return gsresponse.InvalidArgument[gatewayv1.GetTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("nil request"))
+		return gsresponse.InvalidArgument[chainv1.GetTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("nil request"))
 	}
 	transferRef := strings.TrimSpace(req.GetTransferRef())
 	if transferRef == "" {
 		c.deps.Logger.Warn("transfer_ref missing")
-		return gsresponse.InvalidArgument[gatewayv1.GetTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("transfer_ref is required"))
+		return gsresponse.InvalidArgument[chainv1.GetTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("transfer_ref is required"))
 	}
 	transfer, err := c.deps.Storage.Transfers().Get(ctx, transferRef)
 	if err != nil {
 		if errors.Is(err, merrors.ErrNoData) {
 			c.deps.Logger.Warn("not found", zap.String("transfer_ref", transferRef))
-			return gsresponse.NotFound[gatewayv1.GetTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
+			return gsresponse.NotFound[chainv1.GetTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
 		}
 		c.deps.Logger.Warn("storage get failed", zap.Error(err), zap.String("transfer_ref", transferRef))
-		return gsresponse.Auto[gatewayv1.GetTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Auto[chainv1.GetTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
-	return gsresponse.Success(&gatewayv1.GetTransferResponse{Transfer: toProtoTransfer(transfer)})
+	return gsresponse.Success(&chainv1.GetTransferResponse{Transfer: toProtoTransfer(transfer)})
 }

api/gateway/chain/internal/service/gateway/commands/transfer/list.go

@@ -4,12 +4,12 @@ import (
 	"context"
 	"strings"
 
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/api/routers/gsresponse"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
 	paginationv1 "github.com/tech/sendico/pkg/proto/common/pagination/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"go.uber.org/zap"
 )
 
@@ -21,10 +21,10 @@ func NewListTransfers(deps Deps) *listTransfersCommand {
 	return &listTransfersCommand{deps: deps}
 }
 
-func (c *listTransfersCommand) Execute(ctx context.Context, req *gatewayv1.ListTransfersRequest) gsresponse.Responder[gatewayv1.ListTransfersResponse] {
+func (c *listTransfersCommand) Execute(ctx context.Context, req *chainv1.ListTransfersRequest) gsresponse.Responder[chainv1.ListTransfersResponse] {
 	if err := c.deps.EnsureRepository(ctx); err != nil {
 		c.deps.Logger.Warn("repository unavailable", zap.Error(err))
-		return gsresponse.Unavailable[gatewayv1.ListTransfersResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Unavailable[chainv1.ListTransfersResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 	filter := model.TransferFilter{}
 	if req != nil {
@@ -42,15 +42,15 @@ func (c *listTransfersCommand) Execute(ctx context.Context, req *gatewayv1.ListT
 	result, err := c.deps.Storage.Transfers().List(ctx, filter)
 	if err != nil {
 		c.deps.Logger.Warn("storage list failed", zap.Error(err))
-		return gsresponse.Auto[gatewayv1.ListTransfersResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Auto[chainv1.ListTransfersResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 
-	protoTransfers := make([]*gatewayv1.Transfer, 0, len(result.Items))
+	protoTransfers := make([]*chainv1.Transfer, 0, len(result.Items))
 	for _, transfer := range result.Items {
 		protoTransfers = append(protoTransfers, toProtoTransfer(transfer))
 	}
 
-	resp := &gatewayv1.ListTransfersResponse{
+	resp := &chainv1.ListTransfersResponse{
 		Transfers: protoTransfers,
 		Page:      &paginationv1.CursorPageResponse{NextCursor: result.NextCursor},
 	}

api/gateway/chain/internal/service/gateway/commands/transfer/proto.go

@@ -1,40 +1,40 @@
 package transfer
 
 import (
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
-func toProtoTransfer(transfer *model.Transfer) *gatewayv1.Transfer {
+func toProtoTransfer(transfer *model.Transfer) *chainv1.Transfer {
 	if transfer == nil {
 		return nil
 	}
-	destination := &gatewayv1.TransferDestination{}
+	destination := &chainv1.TransferDestination{}
 	if transfer.Destination.ManagedWalletRef != "" {
-		destination.Destination = &gatewayv1.TransferDestination_ManagedWalletRef{ManagedWalletRef: transfer.Destination.ManagedWalletRef}
+		destination.Destination = &chainv1.TransferDestination_ManagedWalletRef{ManagedWalletRef: transfer.Destination.ManagedWalletRef}
 	} else if transfer.Destination.ExternalAddress != "" {
-		destination.Destination = &gatewayv1.TransferDestination_ExternalAddress{ExternalAddress: transfer.Destination.ExternalAddress}
+		destination.Destination = &chainv1.TransferDestination_ExternalAddress{ExternalAddress: transfer.Destination.ExternalAddress}
 	}
 	destination.Memo = transfer.Destination.Memo
 
-	protoFees := make([]*gatewayv1.ServiceFeeBreakdown, 0, len(transfer.Fees))
+	protoFees := make([]*chainv1.ServiceFeeBreakdown, 0, len(transfer.Fees))
 	for _, fee := range transfer.Fees {
-		protoFees = append(protoFees, &gatewayv1.ServiceFeeBreakdown{
+		protoFees = append(protoFees, &chainv1.ServiceFeeBreakdown{
 			FeeCode:     fee.FeeCode,
 			Amount:      shared.CloneMoney(fee.Amount),
 			Description: fee.Description,
 		})
 	}
 
-	asset := &gatewayv1.Asset{
+	asset := &chainv1.Asset{
 		Chain:           shared.ChainEnumFromName(transfer.Network),
 		TokenSymbol:     transfer.TokenSymbol,
 		ContractAddress: transfer.ContractAddress,
 	}
 
-	return &gatewayv1.Transfer{
+	return &chainv1.Transfer{
 		TransferRef:     transfer.TransferRef,
 		IdempotencyKey:  transfer.IdempotencyKey,
 		OrganizationRef: transfer.OrganizationRef,

api/gateway/chain/internal/service/gateway/commands/transfer/submit.go

@@ -6,12 +6,12 @@ import (
 	"strings"
 
 	"github.com/shopspring/decimal"
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/api/routers/gsresponse"
 	"github.com/tech/sendico/pkg/merrors"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"go.uber.org/zap"
 )
 
@@ -23,91 +23,91 @@ func NewSubmitTransfer(deps Deps) *submitTransferCommand {
 	return &submitTransferCommand{deps: deps}
 }
 
-func (c *submitTransferCommand) Execute(ctx context.Context, req *gatewayv1.SubmitTransferRequest) gsresponse.Responder[gatewayv1.SubmitTransferResponse] {
+func (c *submitTransferCommand) Execute(ctx context.Context, req *chainv1.SubmitTransferRequest) gsresponse.Responder[chainv1.SubmitTransferResponse] {
 	if err := c.deps.EnsureRepository(ctx); err != nil {
 		c.deps.Logger.Warn("repository unavailable", zap.Error(err))
-		return gsresponse.Unavailable[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Unavailable[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 	if req == nil {
 		c.deps.Logger.Warn("nil request")
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("nil request"))
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("nil request"))
 	}
 
 	idempotencyKey := strings.TrimSpace(req.GetIdempotencyKey())
 	if idempotencyKey == "" {
 		c.deps.Logger.Warn("missing idempotency key")
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("idempotency_key is required"))
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("idempotency_key is required"))
 	}
 	organizationRef := strings.TrimSpace(req.GetOrganizationRef())
 	if organizationRef == "" {
 		c.deps.Logger.Warn("missing organization ref")
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("organization_ref is required"))
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("organization_ref is required"))
 	}
 	sourceWalletRef := strings.TrimSpace(req.GetSourceWalletRef())
 	if sourceWalletRef == "" {
 		c.deps.Logger.Warn("missing source wallet ref")
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("source_wallet_ref is required"))
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("source_wallet_ref is required"))
 	}
 	amount := req.GetAmount()
 	if amount == nil {
 		c.deps.Logger.Warn("missing amount")
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("amount is required"))
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("amount is required"))
 	}
 	amountCurrency := strings.ToUpper(strings.TrimSpace(amount.GetCurrency()))
 	if amountCurrency == "" {
 		c.deps.Logger.Warn("missing amount currency")
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("amount.currency is required"))
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("amount.currency is required"))
 	}
 	amountValue := strings.TrimSpace(amount.GetAmount())
 	if amountValue == "" {
 		c.deps.Logger.Warn("missing amount value")
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("amount.amount is required"))
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("amount.amount is required"))
 	}
 
 	sourceWallet, err := c.deps.Storage.Wallets().Get(ctx, sourceWalletRef)
 	if err != nil {
 		if errors.Is(err, merrors.ErrNoData) {
 			c.deps.Logger.Warn("source wallet not found", zap.String("source_wallet_ref", sourceWalletRef))
-			return gsresponse.NotFound[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
+			return gsresponse.NotFound[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
 		}
 		c.deps.Logger.Warn("storage get wallet failed", zap.Error(err), zap.String("source_wallet_ref", sourceWalletRef))
-		return gsresponse.Auto[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Auto[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 	if !strings.EqualFold(sourceWallet.OrganizationRef, organizationRef) {
 		c.deps.Logger.Warn("organization mismatch", zap.String("wallet_org", sourceWallet.OrganizationRef), zap.String("req_org", organizationRef))
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("organization_ref mismatch with wallet"))
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("organization_ref mismatch with wallet"))
 	}
 	networkKey := strings.ToLower(strings.TrimSpace(sourceWallet.Network))
 	networkCfg, ok := c.deps.Networks[networkKey]
 	if !ok {
 		c.deps.Logger.Warn("unsupported chain", zap.String("network", networkKey))
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("unsupported chain for wallet"))
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("unsupported chain for wallet"))
 	}
 
 	destination, err := resolveDestination(ctx, c.deps, req.GetDestination(), sourceWallet)
 	if err != nil {
 		if errors.Is(err, merrors.ErrNoData) {
 			c.deps.Logger.Warn("destination not found", zap.String("destination_wallet_ref", req.GetDestination().GetManagedWalletRef()))
-			return gsresponse.NotFound[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
+			return gsresponse.NotFound[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
 		}
 		c.deps.Logger.Warn("invalid destination", zap.Error(err))
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 
 	fees, feeSum, err := convertFees(req.GetFees(), amountCurrency)
 	if err != nil {
 		c.deps.Logger.Warn("fee conversion failed", zap.Error(err))
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 	amountDec, err := decimal.NewFromString(amountValue)
 	if err != nil {
 		c.deps.Logger.Warn("invalid amount", zap.Error(err))
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("invalid amount"))
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("invalid amount"))
 	}
 	netDec := amountDec.Sub(feeSum)
 	if netDec.IsNegative() {
 		c.deps.Logger.Warn("fees exceed amount", zap.String("amount", amountValue), zap.String("fee_sum", feeSum.String()))
-		return gsresponse.InvalidArgument[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("fees exceed amount"))
+		return gsresponse.InvalidArgument[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("fees exceed amount"))
 	}
 
 	netAmount := shared.CloneMoney(amount)
@@ -134,15 +134,15 @@ func (c *submitTransferCommand) Execute(ctx context.Context, req *gatewayv1.Subm
 	if err != nil {
 		if errors.Is(err, merrors.ErrDataConflict) {
 			c.deps.Logger.Debug("transfer already exists", zap.String("transfer_ref", transfer.TransferRef), zap.String("idempotency_key", idempotencyKey))
-			return gsresponse.Success(&gatewayv1.SubmitTransferResponse{Transfer: toProtoTransfer(saved)})
+			return gsresponse.Success(&chainv1.SubmitTransferResponse{Transfer: toProtoTransfer(saved)})
 		}
 		c.deps.Logger.Warn("storage create failed", zap.Error(err), zap.String("transfer_ref", transfer.TransferRef))
-		return gsresponse.Auto[gatewayv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Auto[chainv1.SubmitTransferResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 
 	if c.deps.LaunchExecution != nil {
 		c.deps.LaunchExecution(saved.TransferRef, sourceWalletRef, networkCfg)
 	}
 
-	return gsresponse.Success(&gatewayv1.SubmitTransferResponse{Transfer: toProtoTransfer(saved)})
+	return gsresponse.Success(&chainv1.SubmitTransferResponse{Transfer: toProtoTransfer(saved)})
 }

api/gateway/chain/internal/service/gateway/commands/wallet/balance.go

@@ -8,8 +8,8 @@ import (
 	"github.com/tech/sendico/pkg/api/routers/gsresponse"
 	"github.com/tech/sendico/pkg/merrors"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
 	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"go.uber.org/zap"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
@@ -22,28 +22,28 @@ func NewGetWalletBalance(deps Deps) *getWalletBalanceCommand {
 	return &getWalletBalanceCommand{deps: deps}
 }
 
-func (c *getWalletBalanceCommand) Execute(ctx context.Context, req *gatewayv1.GetWalletBalanceRequest) gsresponse.Responder[gatewayv1.GetWalletBalanceResponse] {
+func (c *getWalletBalanceCommand) Execute(ctx context.Context, req *chainv1.GetWalletBalanceRequest) gsresponse.Responder[chainv1.GetWalletBalanceResponse] {
 	if err := c.deps.EnsureRepository(ctx); err != nil {
 		c.deps.Logger.Warn("repository unavailable", zap.Error(err))
-		return gsresponse.Unavailable[gatewayv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Unavailable[chainv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 	if req == nil {
 		c.deps.Logger.Warn("nil request")
-		return gsresponse.InvalidArgument[gatewayv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("nil request"))
+		return gsresponse.InvalidArgument[chainv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("nil request"))
 	}
 	walletRef := strings.TrimSpace(req.GetWalletRef())
 	if walletRef == "" {
 		c.deps.Logger.Warn("wallet_ref missing")
-		return gsresponse.InvalidArgument[gatewayv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("wallet_ref is required"))
+		return gsresponse.InvalidArgument[chainv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("wallet_ref is required"))
 	}
 	wallet, err := c.deps.Storage.Wallets().Get(ctx, walletRef)
 	if err != nil {
 		if errors.Is(err, merrors.ErrNoData) {
 			c.deps.Logger.Warn("not found", zap.String("wallet_ref", walletRef))
-			return gsresponse.NotFound[gatewayv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, err)
+			return gsresponse.NotFound[chainv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, err)
 		}
 		c.deps.Logger.Warn("storage get failed", zap.Error(err), zap.String("wallet_ref", walletRef))
-		return gsresponse.Auto[gatewayv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Auto[chainv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 
 	balance, chainErr := onChainWalletBalance(ctx, c.deps, wallet)
@@ -53,22 +53,22 @@ func (c *getWalletBalanceCommand) Execute(ctx context.Context, req *gatewayv1.Ge
 		if err != nil {
 			if errors.Is(err, merrors.ErrNoData) {
 				c.deps.Logger.Warn("stored balance not found", zap.String("wallet_ref", walletRef))
-				return gsresponse.NotFound[gatewayv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, err)
+				return gsresponse.NotFound[chainv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, err)
 			}
-			return gsresponse.Auto[gatewayv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, err)
+			return gsresponse.Auto[chainv1.GetWalletBalanceResponse](c.deps.Logger, mservice.ChainGateway, err)
 		}
-		return gsresponse.Success(&gatewayv1.GetWalletBalanceResponse{Balance: toProtoWalletBalance(stored)})
+		return gsresponse.Success(&chainv1.GetWalletBalanceResponse{Balance: toProtoWalletBalance(stored)})
 	}
 
-	return gsresponse.Success(&gatewayv1.GetWalletBalanceResponse{Balance: onChainBalanceToProto(balance)})
+	return gsresponse.Success(&chainv1.GetWalletBalanceResponse{Balance: onChainBalanceToProto(balance)})
 }
 
-func onChainBalanceToProto(balance *moneyv1.Money) *gatewayv1.WalletBalance {
+func onChainBalanceToProto(balance *moneyv1.Money) *chainv1.WalletBalance {
 	if balance == nil {
 		return nil
 	}
 	zero := &moneyv1.Money{Currency: balance.Currency, Amount: "0"}
-	return &gatewayv1.WalletBalance{
+	return &chainv1.WalletBalance{
 		Available:       balance,
 		PendingInbound:  zero,
 		PendingOutbound: zero,

api/gateway/chain/internal/service/gateway/commands/wallet/create.go

@@ -5,12 +5,12 @@ import (
 	"errors"
 	"strings"
 
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/api/routers/gsresponse"
 	"github.com/tech/sendico/pkg/merrors"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"go.uber.org/zap"
 )
 
@@ -22,77 +22,77 @@ func NewCreateManagedWallet(deps Deps) *createManagedWalletCommand {
 	return &createManagedWalletCommand{deps: deps}
 }
 
-func (c *createManagedWalletCommand) Execute(ctx context.Context, req *gatewayv1.CreateManagedWalletRequest) gsresponse.Responder[gatewayv1.CreateManagedWalletResponse] {
+func (c *createManagedWalletCommand) Execute(ctx context.Context, req *chainv1.CreateManagedWalletRequest) gsresponse.Responder[chainv1.CreateManagedWalletResponse] {
 	if err := c.deps.EnsureRepository(ctx); err != nil {
 		c.deps.Logger.Warn("repository unavailable", zap.Error(err))
-		return gsresponse.Unavailable[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Unavailable[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 	if req == nil {
 		c.deps.Logger.Warn("nil request")
-		return gsresponse.InvalidArgument[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("nil request"))
+		return gsresponse.InvalidArgument[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("nil request"))
 	}
 
 	idempotencyKey := strings.TrimSpace(req.GetIdempotencyKey())
 	if idempotencyKey == "" {
 		c.deps.Logger.Warn("missing idempotency key")
-		return gsresponse.InvalidArgument[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("idempotency_key is required"))
+		return gsresponse.InvalidArgument[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("idempotency_key is required"))
 	}
 	organizationRef := strings.TrimSpace(req.GetOrganizationRef())
 	if organizationRef == "" {
 		c.deps.Logger.Warn("missing organization ref")
-		return gsresponse.InvalidArgument[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("organization_ref is required"))
+		return gsresponse.InvalidArgument[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("organization_ref is required"))
 	}
 	ownerRef := strings.TrimSpace(req.GetOwnerRef())
 	if ownerRef == "" {
 		c.deps.Logger.Warn("missing owner ref")
-		return gsresponse.InvalidArgument[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("owner_ref is required"))
+		return gsresponse.InvalidArgument[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("owner_ref is required"))
 	}
 
 	asset := req.GetAsset()
 	if asset == nil {
 		c.deps.Logger.Warn("missing asset")
-		return gsresponse.InvalidArgument[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("asset is required"))
+		return gsresponse.InvalidArgument[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("asset is required"))
 	}
 
 	chainKey, _ := shared.ChainKeyFromEnum(asset.GetChain())
 	if chainKey == "" {
 		c.deps.Logger.Warn("unsupported chain", zap.Any("chain", asset.GetChain()))
-		return gsresponse.InvalidArgument[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("unsupported chain"))
+		return gsresponse.InvalidArgument[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("unsupported chain"))
 	}
 	networkCfg, ok := c.deps.Networks[chainKey]
 	if !ok {
 		c.deps.Logger.Warn("unsupported chain in config", zap.String("chain", chainKey))
-		return gsresponse.InvalidArgument[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("unsupported chain"))
+		return gsresponse.InvalidArgument[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("unsupported chain"))
 	}
 
 	tokenSymbol := strings.ToUpper(strings.TrimSpace(asset.GetTokenSymbol()))
 	if tokenSymbol == "" {
 		c.deps.Logger.Warn("missing token symbol")
-		return gsresponse.InvalidArgument[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("asset.token_symbol is required"))
+		return gsresponse.InvalidArgument[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("asset.token_symbol is required"))
 	}
 	contractAddress := strings.ToLower(strings.TrimSpace(asset.GetContractAddress()))
 	if contractAddress == "" {
 		contractAddress = shared.ResolveContractAddress(networkCfg.TokenConfigs, tokenSymbol)
 		if contractAddress == "" {
 			c.deps.Logger.Warn("unsupported token", zap.String("token", tokenSymbol), zap.String("chain", chainKey))
-			return gsresponse.InvalidArgument[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("unsupported token for chain"))
+			return gsresponse.InvalidArgument[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("unsupported token for chain"))
 		}
 	}
 
 	walletRef := shared.GenerateWalletRef()
 	if c.deps.KeyManager == nil {
 		c.deps.Logger.Warn("key manager missing")
-		return gsresponse.Internal[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.Internal("key manager not configured"))
+		return gsresponse.Internal[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.Internal("key manager not configured"))
 	}
 
 	keyInfo, err := c.deps.KeyManager.CreateManagedWalletKey(ctx, walletRef, chainKey)
 	if err != nil {
 		c.deps.Logger.Warn("key manager error", zap.Error(err))
-		return gsresponse.Auto[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Auto[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 	if keyInfo == nil || strings.TrimSpace(keyInfo.Address) == "" {
 		c.deps.Logger.Warn("key manager returned empty address")
-		return gsresponse.Internal[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.Internal("key manager returned empty address"))
+		return gsresponse.Internal[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.Internal("key manager returned empty address"))
 	}
 
 	wallet := &model.ManagedWallet{
@@ -113,11 +113,11 @@ func (c *createManagedWalletCommand) Execute(ctx context.Context, req *gatewayv1
 	if err != nil {
 		if errors.Is(err, merrors.ErrDataConflict) {
 			c.deps.Logger.Debug("wallet already exists", zap.String("wallet_ref", walletRef), zap.String("idempotency_key", idempotencyKey))
-			return gsresponse.Success(&gatewayv1.CreateManagedWalletResponse{Wallet: toProtoManagedWallet(created)})
+			return gsresponse.Success(&chainv1.CreateManagedWalletResponse{Wallet: toProtoManagedWallet(created)})
 		}
 		c.deps.Logger.Warn("storage create failed", zap.Error(err), zap.String("wallet_ref", walletRef))
-		return gsresponse.Auto[gatewayv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Auto[chainv1.CreateManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 
-	return gsresponse.Success(&gatewayv1.CreateManagedWalletResponse{Wallet: toProtoManagedWallet(created)})
+	return gsresponse.Success(&chainv1.CreateManagedWalletResponse{Wallet: toProtoManagedWallet(created)})
 }

api/gateway/chain/internal/service/gateway/commands/wallet/deps.go

@@ -3,9 +3,9 @@ package wallet
 import (
 	"context"
 
-	"github.com/tech/sendico/chain/gateway/internal/keymanager"
+	"github.com/tech/sendico/gateway/chain/internal/keymanager"
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage"
+	"github.com/tech/sendico/gateway/chain/storage"
 	"github.com/tech/sendico/pkg/mlogger"
 )
 

api/gateway/chain/internal/service/gateway/commands/wallet/get.go

@@ -8,7 +8,7 @@ import (
 	"github.com/tech/sendico/pkg/api/routers/gsresponse"
 	"github.com/tech/sendico/pkg/merrors"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"go.uber.org/zap"
 )
 
@@ -20,28 +20,28 @@ func NewGetManagedWallet(deps Deps) *getManagedWalletCommand {
 	return &getManagedWalletCommand{deps: deps}
 }
 
-func (c *getManagedWalletCommand) Execute(ctx context.Context, req *gatewayv1.GetManagedWalletRequest) gsresponse.Responder[gatewayv1.GetManagedWalletResponse] {
+func (c *getManagedWalletCommand) Execute(ctx context.Context, req *chainv1.GetManagedWalletRequest) gsresponse.Responder[chainv1.GetManagedWalletResponse] {
 	if err := c.deps.EnsureRepository(ctx); err != nil {
 		c.deps.Logger.Warn("repository unavailable", zap.Error(err))
-		return gsresponse.Unavailable[gatewayv1.GetManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Unavailable[chainv1.GetManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 	if req == nil {
 		c.deps.Logger.Warn("nil request")
-		return gsresponse.InvalidArgument[gatewayv1.GetManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("nil request"))
+		return gsresponse.InvalidArgument[chainv1.GetManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("nil request"))
 	}
 	walletRef := strings.TrimSpace(req.GetWalletRef())
 	if walletRef == "" {
 		c.deps.Logger.Warn("wallet_ref missing")
-		return gsresponse.InvalidArgument[gatewayv1.GetManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("wallet_ref is required"))
+		return gsresponse.InvalidArgument[chainv1.GetManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, merrors.InvalidArgument("wallet_ref is required"))
 	}
 	wallet, err := c.deps.Storage.Wallets().Get(ctx, walletRef)
 	if err != nil {
 		if errors.Is(err, merrors.ErrNoData) {
 			c.deps.Logger.Warn("not found", zap.String("wallet_ref", walletRef))
-			return gsresponse.NotFound[gatewayv1.GetManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, err)
+			return gsresponse.NotFound[chainv1.GetManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, err)
 		}
 		c.deps.Logger.Warn("storage get failed", zap.Error(err), zap.String("wallet_ref", walletRef))
-		return gsresponse.Auto[gatewayv1.GetManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Auto[chainv1.GetManagedWalletResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
-	return gsresponse.Success(&gatewayv1.GetManagedWalletResponse{Wallet: toProtoManagedWallet(wallet)})
+	return gsresponse.Success(&chainv1.GetManagedWalletResponse{Wallet: toProtoManagedWallet(wallet)})
 }

api/gateway/chain/internal/service/gateway/commands/wallet/list.go

@@ -4,12 +4,12 @@ import (
 	"context"
 	"strings"
 
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/api/routers/gsresponse"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
 	paginationv1 "github.com/tech/sendico/pkg/proto/common/pagination/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"go.uber.org/zap"
 )
 
@@ -21,10 +21,10 @@ func NewListManagedWallets(deps Deps) *listManagedWalletsCommand {
 	return &listManagedWalletsCommand{deps: deps}
 }
 
-func (c *listManagedWalletsCommand) Execute(ctx context.Context, req *gatewayv1.ListManagedWalletsRequest) gsresponse.Responder[gatewayv1.ListManagedWalletsResponse] {
+func (c *listManagedWalletsCommand) Execute(ctx context.Context, req *chainv1.ListManagedWalletsRequest) gsresponse.Responder[chainv1.ListManagedWalletsResponse] {
 	if err := c.deps.EnsureRepository(ctx); err != nil {
 		c.deps.Logger.Warn("repository unavailable", zap.Error(err))
-		return gsresponse.Unavailable[gatewayv1.ListManagedWalletsResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Unavailable[chainv1.ListManagedWalletsResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 	filter := model.ManagedWalletFilter{}
 	if req != nil {
@@ -43,15 +43,15 @@ func (c *listManagedWalletsCommand) Execute(ctx context.Context, req *gatewayv1.
 	result, err := c.deps.Storage.Wallets().List(ctx, filter)
 	if err != nil {
 		c.deps.Logger.Warn("storage list failed", zap.Error(err))
-		return gsresponse.Auto[gatewayv1.ListManagedWalletsResponse](c.deps.Logger, mservice.ChainGateway, err)
+		return gsresponse.Auto[chainv1.ListManagedWalletsResponse](c.deps.Logger, mservice.ChainGateway, err)
 	}
 
-	protoWallets := make([]*gatewayv1.ManagedWallet, 0, len(result.Items))
+	protoWallets := make([]*chainv1.ManagedWallet, 0, len(result.Items))
 	for _, wallet := range result.Items {
 		protoWallets = append(protoWallets, toProtoManagedWallet(wallet))
 	}
 
-	resp := &gatewayv1.ListManagedWalletsResponse{
+	resp := &chainv1.ListManagedWalletsResponse{
 		Wallets: protoWallets,
 		Page:    &paginationv1.CursorPageResponse{NextCursor: result.NextCursor},
 	}

api/gateway/chain/internal/service/gateway/commands/wallet/onchain_balance.go

@@ -11,7 +11,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/shopspring/decimal"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/merrors"
 	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
 )

api/gateway/chain/internal/service/gateway/commands/wallet/proto.go

@@ -1,22 +1,22 @@
 package wallet
 
 import (
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
-func toProtoManagedWallet(wallet *model.ManagedWallet) *gatewayv1.ManagedWallet {
+func toProtoManagedWallet(wallet *model.ManagedWallet) *chainv1.ManagedWallet {
 	if wallet == nil {
 		return nil
 	}
-	asset := &gatewayv1.Asset{
+	asset := &chainv1.Asset{
 		Chain:           shared.ChainEnumFromName(wallet.Network),
 		TokenSymbol:     wallet.TokenSymbol,
 		ContractAddress: wallet.ContractAddress,
 	}
-	return &gatewayv1.ManagedWallet{
+	return &chainv1.ManagedWallet{
 		WalletRef:       wallet.WalletRef,
 		OrganizationRef: wallet.OrganizationRef,
 		OwnerRef:        wallet.OwnerRef,
@@ -29,11 +29,11 @@ func toProtoManagedWallet(wallet *model.ManagedWallet) *gatewayv1.ManagedWallet
 	}
 }
 
-func toProtoWalletBalance(balance *model.WalletBalance) *gatewayv1.WalletBalance {
+func toProtoWalletBalance(balance *model.WalletBalance) *chainv1.WalletBalance {
 	if balance == nil {
 		return nil
 	}
-	return &gatewayv1.WalletBalance{
+	return &chainv1.WalletBalance{
 		Available:       shared.CloneMoney(balance.Available),
 		PendingInbound:  shared.CloneMoney(balance.PendingInbound),
 		PendingOutbound: shared.CloneMoney(balance.PendingOutbound),

api/gateway/chain/internal/service/gateway/executor.go

@@ -14,11 +14,11 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/shopspring/decimal"
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
 	"go.uber.org/zap"
 
-	"github.com/tech/sendico/chain/gateway/internal/keymanager"
+	"github.com/tech/sendico/gateway/chain/internal/keymanager"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/merrors"
 	"github.com/tech/sendico/pkg/mlogger"
 )

api/gateway/chain/internal/service/gateway/options.go

@@ -3,8 +3,8 @@ package gateway
 import (
 	"strings"
 
-	"github.com/tech/sendico/chain/gateway/internal/keymanager"
+	"github.com/tech/sendico/gateway/chain/internal/keymanager"
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
 	clockpkg "github.com/tech/sendico/pkg/clock"
 )
 

api/gateway/chain/internal/service/gateway/service.go

@@ -3,19 +3,19 @@ package gateway
 import (
 	"context"
 
-	"github.com/tech/sendico/chain/gateway/internal/keymanager"
+	"github.com/tech/sendico/gateway/chain/internal/keymanager"
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/commands"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/commands"
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/commands/transfer"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/commands/transfer"
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/commands/wallet"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/commands/wallet"
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage"
+	"github.com/tech/sendico/gateway/chain/storage"
 	"github.com/tech/sendico/pkg/api/routers"
 	"github.com/tech/sendico/pkg/api/routers/gsresponse"
 	clockpkg "github.com/tech/sendico/pkg/clock"
 	msg "github.com/tech/sendico/pkg/messaging"
 	"github.com/tech/sendico/pkg/mlogger"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"google.golang.org/grpc"
 )
 
@@ -42,7 +42,7 @@ type Service struct {
 	executor      TransferExecutor
 	commands      commands.Registry
 
-	gatewayv1.UnimplementedChainGatewayServiceServer
+	chainv1.UnimplementedChainGatewayServiceServer
 }
 
 // NewService constructs the chain gateway service skeleton.
@@ -81,39 +81,39 @@ func NewService(logger mlogger.Logger, repo storage.Repository, producer msg.Pro
 // Register wires the service onto the provided gRPC router.
 func (s *Service) Register(router routers.GRPC) error {
 	return router.Register(func(reg grpc.ServiceRegistrar) {
-		gatewayv1.RegisterChainGatewayServiceServer(reg, s)
+		chainv1.RegisterChainGatewayServiceServer(reg, s)
 	})
 }
 
-func (s *Service) CreateManagedWallet(ctx context.Context, req *gatewayv1.CreateManagedWalletRequest) (*gatewayv1.CreateManagedWalletResponse, error) {
+func (s *Service) CreateManagedWallet(ctx context.Context, req *chainv1.CreateManagedWalletRequest) (*chainv1.CreateManagedWalletResponse, error) {
 	return executeUnary(ctx, s, "CreateManagedWallet", s.commands.CreateManagedWallet.Execute, req)
 }
 
-func (s *Service) GetManagedWallet(ctx context.Context, req *gatewayv1.GetManagedWalletRequest) (*gatewayv1.GetManagedWalletResponse, error) {
+func (s *Service) GetManagedWallet(ctx context.Context, req *chainv1.GetManagedWalletRequest) (*chainv1.GetManagedWalletResponse, error) {
 	return executeUnary(ctx, s, "GetManagedWallet", s.commands.GetManagedWallet.Execute, req)
 }
 
-func (s *Service) ListManagedWallets(ctx context.Context, req *gatewayv1.ListManagedWalletsRequest) (*gatewayv1.ListManagedWalletsResponse, error) {
+func (s *Service) ListManagedWallets(ctx context.Context, req *chainv1.ListManagedWalletsRequest) (*chainv1.ListManagedWalletsResponse, error) {
 	return executeUnary(ctx, s, "ListManagedWallets", s.commands.ListManagedWallets.Execute, req)
 }
 
-func (s *Service) GetWalletBalance(ctx context.Context, req *gatewayv1.GetWalletBalanceRequest) (*gatewayv1.GetWalletBalanceResponse, error) {
+func (s *Service) GetWalletBalance(ctx context.Context, req *chainv1.GetWalletBalanceRequest) (*chainv1.GetWalletBalanceResponse, error) {
 	return executeUnary(ctx, s, "GetWalletBalance", s.commands.GetWalletBalance.Execute, req)
 }
 
-func (s *Service) SubmitTransfer(ctx context.Context, req *gatewayv1.SubmitTransferRequest) (*gatewayv1.SubmitTransferResponse, error) {
+func (s *Service) SubmitTransfer(ctx context.Context, req *chainv1.SubmitTransferRequest) (*chainv1.SubmitTransferResponse, error) {
 	return executeUnary(ctx, s, "SubmitTransfer", s.commands.SubmitTransfer.Execute, req)
 }
 
-func (s *Service) GetTransfer(ctx context.Context, req *gatewayv1.GetTransferRequest) (*gatewayv1.GetTransferResponse, error) {
+func (s *Service) GetTransfer(ctx context.Context, req *chainv1.GetTransferRequest) (*chainv1.GetTransferResponse, error) {
 	return executeUnary(ctx, s, "GetTransfer", s.commands.GetTransfer.Execute, req)
 }
 
-func (s *Service) ListTransfers(ctx context.Context, req *gatewayv1.ListTransfersRequest) (*gatewayv1.ListTransfersResponse, error) {
+func (s *Service) ListTransfers(ctx context.Context, req *chainv1.ListTransfersRequest) (*chainv1.ListTransfersResponse, error) {
 	return executeUnary(ctx, s, "ListTransfers", s.commands.ListTransfers.Execute, req)
 }
 
-func (s *Service) EstimateTransferFee(ctx context.Context, req *gatewayv1.EstimateTransferFeeRequest) (*gatewayv1.EstimateTransferFeeResponse, error) {
+func (s *Service) EstimateTransferFee(ctx context.Context, req *chainv1.EstimateTransferFeeRequest) (*chainv1.EstimateTransferFeeResponse, error) {
 	return executeUnary(ctx, s, "EstimateTransferFee", s.commands.EstimateTransfer.Execute, req)
 }
 

api/gateway/chain/internal/service/gateway/service_test.go

@@ -11,16 +11,16 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/require"
-	igatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	ichainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.uber.org/zap"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 
-	"github.com/tech/sendico/chain/gateway/internal/keymanager"
+	"github.com/tech/sendico/gateway/chain/internal/keymanager"
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
-	"github.com/tech/sendico/chain/gateway/storage"
+	"github.com/tech/sendico/gateway/chain/storage"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/merrors"
 	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
 	paginationv1 "github.com/tech/sendico/pkg/proto/common/pagination/v1"
@@ -41,12 +41,12 @@ func TestCreateManagedWallet_Idempotent(t *testing.T) {
 	svc, repo := newTestService(t)
 
 	ctx := context.Background()
-	req := &igatewayv1.CreateManagedWalletRequest{
+	req := &ichainv1.CreateManagedWalletRequest{
 		IdempotencyKey:  "idem-1",
 		OrganizationRef: "org-1",
 		OwnerRef:        "owner-1",
-		Asset: &igatewayv1.Asset{
+		Asset: &ichainv1.Asset{
-			Chain:       igatewayv1.ChainNetwork_CHAIN_NETWORK_ETHEREUM_MAINNET,
+			Chain:       ichainv1.ChainNetwork_CHAIN_NETWORK_ETHEREUM_MAINNET,
 			TokenSymbol: "USDC",
 		},
 	}
@@ -70,12 +70,12 @@ func TestSubmitTransfer_ManagedDestination(t *testing.T) {
 	ctx := context.Background()
 
 	// create source wallet
-	srcResp, err := svc.CreateManagedWallet(ctx, &igatewayv1.CreateManagedWalletRequest{
+	srcResp, err := svc.CreateManagedWallet(ctx, &ichainv1.CreateManagedWalletRequest{
 		IdempotencyKey:  "idem-src",
 		OrganizationRef: "org-1",
 		OwnerRef:        "owner-1",
-		Asset: &igatewayv1.Asset{
+		Asset: &ichainv1.Asset{
-			Chain:       igatewayv1.ChainNetwork_CHAIN_NETWORK_ETHEREUM_MAINNET,
+			Chain:       ichainv1.ChainNetwork_CHAIN_NETWORK_ETHEREUM_MAINNET,
 			TokenSymbol: "USDC",
 		},
 	})
@@ -83,27 +83,27 @@ func TestSubmitTransfer_ManagedDestination(t *testing.T) {
 	srcRef := srcResp.GetWallet().GetWalletRef()
 
 	// destination wallet
-	dstResp, err := svc.CreateManagedWallet(ctx, &igatewayv1.CreateManagedWalletRequest{
+	dstResp, err := svc.CreateManagedWallet(ctx, &ichainv1.CreateManagedWalletRequest{
 		IdempotencyKey:  "idem-dst",
 		OrganizationRef: "org-1",
 		OwnerRef:        "owner-2",
-		Asset: &igatewayv1.Asset{
+		Asset: &ichainv1.Asset{
-			Chain:       igatewayv1.ChainNetwork_CHAIN_NETWORK_ETHEREUM_MAINNET,
+			Chain:       ichainv1.ChainNetwork_CHAIN_NETWORK_ETHEREUM_MAINNET,
 			TokenSymbol: "USDC",
 		},
 	})
 	require.NoError(t, err)
 	dstRef := dstResp.GetWallet().GetWalletRef()
 
-	transferResp, err := svc.SubmitTransfer(ctx, &igatewayv1.SubmitTransferRequest{
+	transferResp, err := svc.SubmitTransfer(ctx, &ichainv1.SubmitTransferRequest{
 		IdempotencyKey:  "transfer-1",
 		OrganizationRef: "org-1",
 		SourceWalletRef: srcRef,
-		Destination: &igatewayv1.TransferDestination{
+		Destination: &ichainv1.TransferDestination{
-			Destination: &igatewayv1.TransferDestination_ManagedWalletRef{ManagedWalletRef: dstRef},
+			Destination: &ichainv1.TransferDestination_ManagedWalletRef{ManagedWalletRef: dstRef},
 		},
 		Amount: &moneyv1.Money{Currency: "USDC", Amount: "100"},
-		Fees: []*igatewayv1.ServiceFeeBreakdown{
+		Fees: []*ichainv1.ServiceFeeBreakdown{
 			{
 				FeeCode: "service",
 				Amount:  &moneyv1.Money{Currency: "USDC", Amount: "5"},
@@ -119,12 +119,12 @@ func TestSubmitTransfer_ManagedDestination(t *testing.T) {
 	require.Equal(t, model.TransferStatusPending, stored.Status)
 
 	// GetTransfer
-	getResp, err := svc.GetTransfer(ctx, &igatewayv1.GetTransferRequest{TransferRef: stored.TransferRef})
+	getResp, err := svc.GetTransfer(ctx, &ichainv1.GetTransferRequest{TransferRef: stored.TransferRef})
 	require.NoError(t, err)
 	require.Equal(t, stored.TransferRef, getResp.GetTransfer().GetTransferRef())
 
 	// ListTransfers
-	listResp, err := svc.ListTransfers(ctx, &igatewayv1.ListTransfersRequest{
+	listResp, err := svc.ListTransfers(ctx, &ichainv1.ListTransfersRequest{
 		SourceWalletRef: srcRef,
 		Page:            &paginationv1.CursorPageRequest{Limit: 10},
 	})
@@ -137,7 +137,7 @@ func TestGetWalletBalance_NotFound(t *testing.T) {
 	svc, _ := newTestService(t)
 	ctx := context.Background()
 
-	_, err := svc.GetWalletBalance(ctx, &igatewayv1.GetWalletBalanceRequest{WalletRef: "missing"})
+	_, err := svc.GetWalletBalance(ctx, &ichainv1.GetWalletBalanceRequest{WalletRef: "missing"})
 	require.Error(t, err)
 	st, _ := status.FromError(err)
 	require.Equal(t, codes.NotFound, st.Code())

api/gateway/chain/internal/service/gateway/shared/helpers.go

@@ -3,9 +3,9 @@ package shared
 import (
 	"strings"
 
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
 	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 )
 
@@ -48,74 +48,74 @@ func GenerateTransferRef() string {
 	return primitive.NewObjectID().Hex()
 }
 
-func ChainKeyFromEnum(chain gatewayv1.ChainNetwork) (string, gatewayv1.ChainNetwork) {
+func ChainKeyFromEnum(chain chainv1.ChainNetwork) (string, chainv1.ChainNetwork) {
-	if name, ok := gatewayv1.ChainNetwork_name[int32(chain)]; ok {
+	if name, ok := chainv1.ChainNetwork_name[int32(chain)]; ok {
 		key := strings.ToLower(strings.TrimPrefix(name, "CHAIN_NETWORK_"))
 		return key, chain
 	}
-	return "", gatewayv1.ChainNetwork_CHAIN_NETWORK_UNSPECIFIED
+	return "", chainv1.ChainNetwork_CHAIN_NETWORK_UNSPECIFIED
 }
 
-func ChainEnumFromName(name string) gatewayv1.ChainNetwork {
+func ChainEnumFromName(name string) chainv1.ChainNetwork {
 	if name == "" {
-		return gatewayv1.ChainNetwork_CHAIN_NETWORK_UNSPECIFIED
+		return chainv1.ChainNetwork_CHAIN_NETWORK_UNSPECIFIED
 	}
 	upper := strings.ToUpper(strings.ReplaceAll(strings.ReplaceAll(name, " ", "_"), "-", "_"))
 	key := "CHAIN_NETWORK_" + upper
-	if val, ok := gatewayv1.ChainNetwork_value[key]; ok {
+	if val, ok := chainv1.ChainNetwork_value[key]; ok {
-		return gatewayv1.ChainNetwork(val)
+		return chainv1.ChainNetwork(val)
 	}
-	return gatewayv1.ChainNetwork_CHAIN_NETWORK_UNSPECIFIED
+	return chainv1.ChainNetwork_CHAIN_NETWORK_UNSPECIFIED
 }
 
-func ManagedWalletStatusToProto(status model.ManagedWalletStatus) gatewayv1.ManagedWalletStatus {
+func ManagedWalletStatusToProto(status model.ManagedWalletStatus) chainv1.ManagedWalletStatus {
 	switch status {
 	case model.ManagedWalletStatusActive:
-		return gatewayv1.ManagedWalletStatus_MANAGED_WALLET_ACTIVE
+		return chainv1.ManagedWalletStatus_MANAGED_WALLET_ACTIVE
 	case model.ManagedWalletStatusSuspended:
-		return gatewayv1.ManagedWalletStatus_MANAGED_WALLET_SUSPENDED
+		return chainv1.ManagedWalletStatus_MANAGED_WALLET_SUSPENDED
 	case model.ManagedWalletStatusClosed:
-		return gatewayv1.ManagedWalletStatus_MANAGED_WALLET_CLOSED
+		return chainv1.ManagedWalletStatus_MANAGED_WALLET_CLOSED
 	default:
-		return gatewayv1.ManagedWalletStatus_MANAGED_WALLET_STATUS_UNSPECIFIED
+		return chainv1.ManagedWalletStatus_MANAGED_WALLET_STATUS_UNSPECIFIED
 	}
 }
 
-func TransferStatusToModel(status gatewayv1.TransferStatus) model.TransferStatus {
+func TransferStatusToModel(status chainv1.TransferStatus) model.TransferStatus {
 	switch status {
-	case gatewayv1.TransferStatus_TRANSFER_PENDING:
+	case chainv1.TransferStatus_TRANSFER_PENDING:
 		return model.TransferStatusPending
-	case gatewayv1.TransferStatus_TRANSFER_SIGNING:
+	case chainv1.TransferStatus_TRANSFER_SIGNING:
 		return model.TransferStatusSigning
-	case gatewayv1.TransferStatus_TRANSFER_SUBMITTED:
+	case chainv1.TransferStatus_TRANSFER_SUBMITTED:
 		return model.TransferStatusSubmitted
-	case gatewayv1.TransferStatus_TRANSFER_CONFIRMED:
+	case chainv1.TransferStatus_TRANSFER_CONFIRMED:
 		return model.TransferStatusConfirmed
-	case gatewayv1.TransferStatus_TRANSFER_FAILED:
+	case chainv1.TransferStatus_TRANSFER_FAILED:
 		return model.TransferStatusFailed
-	case gatewayv1.TransferStatus_TRANSFER_CANCELLED:
+	case chainv1.TransferStatus_TRANSFER_CANCELLED:
 		return model.TransferStatusCancelled
 	default:
 		return ""
 	}
 }
 
-func TransferStatusToProto(status model.TransferStatus) gatewayv1.TransferStatus {
+func TransferStatusToProto(status model.TransferStatus) chainv1.TransferStatus {
 	switch status {
 	case model.TransferStatusPending:
-		return gatewayv1.TransferStatus_TRANSFER_PENDING
+		return chainv1.TransferStatus_TRANSFER_PENDING
 	case model.TransferStatusSigning:
-		return gatewayv1.TransferStatus_TRANSFER_SIGNING
+		return chainv1.TransferStatus_TRANSFER_SIGNING
 	case model.TransferStatusSubmitted:
-		return gatewayv1.TransferStatus_TRANSFER_SUBMITTED
+		return chainv1.TransferStatus_TRANSFER_SUBMITTED
 	case model.TransferStatusConfirmed:
-		return gatewayv1.TransferStatus_TRANSFER_CONFIRMED
+		return chainv1.TransferStatus_TRANSFER_CONFIRMED
 	case model.TransferStatusFailed:
-		return gatewayv1.TransferStatus_TRANSFER_FAILED
+		return chainv1.TransferStatus_TRANSFER_FAILED
 	case model.TransferStatusCancelled:
-		return gatewayv1.TransferStatus_TRANSFER_CANCELLED
+		return chainv1.TransferStatus_TRANSFER_CANCELLED
 	default:
-		return gatewayv1.TransferStatus_TRANSFER_STATUS_UNSPECIFIED
+		return chainv1.TransferStatus_TRANSFER_STATUS_UNSPECIFIED
 	}
 }
 

api/gateway/chain/internal/service/gateway/transfer_execution.go

@@ -7,11 +7,11 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/merrors"
 	"go.uber.org/zap"
 
-	"github.com/tech/sendico/chain/gateway/internal/service/gateway/shared"
+	"github.com/tech/sendico/gateway/chain/internal/service/gateway/shared"
 )
 
 func (s *Service) launchTransferExecution(transferRef, sourceWalletRef string, network shared.Network) {

api/gateway/chain/main.go

@@ -1,8 +1,8 @@
 package main
 
 import (
-	"github.com/tech/sendico/chain/gateway/internal/appversion"
+	"github.com/tech/sendico/gateway/chain/internal/appversion"
-	si "github.com/tech/sendico/chain/gateway/internal/server"
+	si "github.com/tech/sendico/gateway/chain/internal/server"
 	"github.com/tech/sendico/pkg/mlogger"
 	"github.com/tech/sendico/pkg/server"
 	smain "github.com/tech/sendico/pkg/server/main"

api/gateway/chain/storage/mongo/repository.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"time"
 
-	"github.com/tech/sendico/chain/gateway/storage"
+	"github.com/tech/sendico/gateway/chain/storage"
-	"github.com/tech/sendico/chain/gateway/storage/mongo/store"
+	"github.com/tech/sendico/gateway/chain/storage/mongo/store"
 	"github.com/tech/sendico/pkg/db"
 	"github.com/tech/sendico/pkg/merrors"
 	"github.com/tech/sendico/pkg/mlogger"

api/gateway/chain/storage/mongo/store/deposits.go

@@ -6,8 +6,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/tech/sendico/chain/gateway/storage"
+	"github.com/tech/sendico/gateway/chain/storage"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/db/repository"
 	ri "github.com/tech/sendico/pkg/db/repository/index"
 	"github.com/tech/sendico/pkg/merrors"

api/gateway/chain/storage/mongo/store/transfers.go

@@ -6,8 +6,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/tech/sendico/chain/gateway/storage"
+	"github.com/tech/sendico/gateway/chain/storage"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/db/repository"
 	"github.com/tech/sendico/pkg/db/repository/builder"
 	ri "github.com/tech/sendico/pkg/db/repository/index"

api/gateway/chain/storage/mongo/store/wallets.go

@@ -6,8 +6,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/tech/sendico/chain/gateway/storage"
+	"github.com/tech/sendico/gateway/chain/storage"
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 	"github.com/tech/sendico/pkg/db/repository"
 	"github.com/tech/sendico/pkg/db/repository/builder"
 	ri "github.com/tech/sendico/pkg/db/repository/index"

api/gateway/chain/storage/storage.go

@@ -3,7 +3,7 @@ package storage
 import (
 	"context"
 
-	"github.com/tech/sendico/chain/gateway/storage/model"
+	"github.com/tech/sendico/gateway/chain/storage/model"
 )
 
 type storageError string

api/ledger/client/fake.go

@@ -8,6 +8,8 @@ import (
 
 // Fake implements Client for tests.
 type Fake struct {
+	CreateAccountFn       func(ctx context.Context, req *ledgerv1.CreateAccountRequest) (*ledgerv1.CreateAccountResponse, error)
+	ListAccountsFn        func(ctx context.Context, req *ledgerv1.ListAccountsRequest) (*ledgerv1.ListAccountsResponse, error)
 	PostCreditWithChargesFn func(ctx context.Context, req *ledgerv1.PostCreditRequest) (*ledgerv1.PostResponse, error)
 	PostDebitWithChargesFn  func(ctx context.Context, req *ledgerv1.PostDebitRequest) (*ledgerv1.PostResponse, error)
 	TransferInternalFn      func(ctx context.Context, req *ledgerv1.TransferRequest) (*ledgerv1.PostResponse, error)
@@ -18,6 +20,20 @@ type Fake struct {
 	CloseFn                 func() error
 }
 
+func (f *Fake) CreateAccount(ctx context.Context, req *ledgerv1.CreateAccountRequest) (*ledgerv1.CreateAccountResponse, error) {
+	if f.CreateAccountFn != nil {
+		return f.CreateAccountFn(ctx, req)
+	}
+	return &ledgerv1.CreateAccountResponse{}, nil
+}
+
+func (f *Fake) ListAccounts(ctx context.Context, req *ledgerv1.ListAccountsRequest) (*ledgerv1.ListAccountsResponse, error) {
+	if f.ListAccountsFn != nil {
+		return f.ListAccountsFn(ctx, req)
+	}
+	return &ledgerv1.ListAccountsResponse{}, nil
+}
+
 func (f *Fake) PostCreditWithCharges(ctx context.Context, req *ledgerv1.PostCreditRequest) (*ledgerv1.PostResponse, error) {
 	if f.PostCreditWithChargesFn != nil {
 		return f.PostCreditWithChargesFn(ctx, req)

api/ledger/internal/service/ledger/queries.go

@@ -249,7 +249,7 @@ func (s *Service) getStatementResponder(_ context.Context, req *ledgerv1.GetStat
 func parseCursor(cursor string) (int, error) {
 	decoded, err := base64.StdEncoding.DecodeString(cursor)
 	if err != nil {
-		return 0, merrors.InvalidArgumentWrap(err, "invalid cursor base64 encoding")
+		return 0, merrors.InvalidArgumentWrap(err, "invalid base64")
 	}
 	parts := strings.Split(string(decoded), ":")
 	if len(parts) != 2 || parts[0] != "offset" {
@@ -257,7 +257,7 @@ func parseCursor(cursor string) (int, error) {
 	}
 	offset, err := strconv.Atoi(parts[1])
 	if err != nil {
-		return 0, merrors.InvalidArgumentWrap(err, "invalid cursor offset")
+		return 0, merrors.InvalidArgumentWrap(err, "invalid offset")
 	}
 	return offset, nil
 }

api/notification/.gitignore

@@ -1 +1,2 @@
 notification
+.gocache

api/payments/orchestrator/go.mod

@@ -6,7 +6,7 @@ replace github.com/tech/sendico/pkg => ../../pkg
 
 replace github.com/tech/sendico/billing/fees => ../../billing/fees
 
-replace github.com/tech/sendico/chain/gateway => ../../chain/gateway
+replace github.com/tech/sendico/gateway/chain => ../../gateway/chain
 
 replace github.com/tech/sendico/fx/oracle => ../../fx/oracle
 
@@ -15,8 +15,8 @@ replace github.com/tech/sendico/ledger => ../../ledger
 require (
 	github.com/prometheus/client_golang v1.23.2
 	github.com/shopspring/decimal v1.4.0
-	github.com/tech/sendico/chain/gateway v0.0.0-00010101000000-000000000000
 	github.com/tech/sendico/fx/oracle v0.0.0-00010101000000-000000000000
+	github.com/tech/sendico/gateway/chain v0.0.0-00010101000000-000000000000
 	github.com/tech/sendico/ledger v0.0.0-00010101000000-000000000000
 	github.com/tech/sendico/pkg v0.1.0
 	go.mongodb.org/mongo-driver v1.17.6
@@ -36,7 +36,7 @@ require (
 	github.com/go-chi/chi/v5 v5.2.3 // indirect
 	github.com/golang/snappy v1.0.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/klauspost/compress v1.18.1 // indirect
+	github.com/klauspost/compress v1.18.2 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
@@ -59,5 +59,5 @@ require (
 	golang.org/x/sync v0.18.0 // indirect
 	golang.org/x/sys v0.38.0 // indirect
 	golang.org/x/text v0.31.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 // indirect
 )

api/payments/orchestrator/go.sum

@@ -59,8 +59,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/klauspost/compress v1.18.1 h1:bcSGx7UbpBqMChDtsF28Lw6v/G94LPrrbMbdC3JH2co=
+github.com/klauspost/compress v1.18.2 h1:iiPHWW0YrcFgpBYhsA6D1+fqHssJscY/Tm/y2Uqnapk=
-github.com/klauspost/compress v1.18.1/go.mod h1:ZQFFVG+MdnR0P+l6wpXgIL4NTtwiKIdBnrBd8Nrxr+0=
+github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@@ -215,8 +215,8 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
 gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846 h1:Wgl1rcDNThT+Zn47YyCXOXyX/COgMTIdhJ717F0l4xk=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 h1:gRkg/vSppuSQoDjxyiGfN4Upv/h/DQmIR10ZU8dh4Ww=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
 google.golang.org/grpc v1.77.0 h1:wVVY6/8cGA6vvffn+wWK5ToddbgdU3d8MNENr4evgXM=
 google.golang.org/grpc v1.77.0/go.mod h1:z0BY1iVj0q8E1uSQCjL9cppRj+gnZjzDnzV0dHhrNig=
 google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=

api/payments/orchestrator/internal/server/internal/serverimp.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"time"
 
-	chainclient "github.com/tech/sendico/chain/gateway/client"
+	chainclient "github.com/tech/sendico/gateway/chain/client"
 	oracleclient "github.com/tech/sendico/fx/oracle/client"
 	ledgerclient "github.com/tech/sendico/ledger/client"
 	"github.com/tech/sendico/payments/orchestrator/internal/service/orchestrator"

api/payments/orchestrator/internal/service/orchestrator/convert.go

@@ -6,9 +6,9 @@ import (
 
 	"github.com/tech/sendico/payments/orchestrator/storage/model"
 	"github.com/tech/sendico/pkg/merrors"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
 	fxv1 "github.com/tech/sendico/pkg/proto/common/fx/v1"
 	paginationv1 "github.com/tech/sendico/pkg/proto/common/pagination/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	oraclev1 "github.com/tech/sendico/pkg/proto/oracle/v1"
 	orchestratorv1 "github.com/tech/sendico/pkg/proto/payments/orchestrator/v1"
 	"google.golang.org/protobuf/proto"
@@ -327,11 +327,11 @@ func protoFailureFromModel(code model.PaymentFailureCode) orchestratorv1.Payment
 	}
 }
 
-func cloneAsset(asset *gatewayv1.Asset) *gatewayv1.Asset {
+func cloneAsset(asset *chainv1.Asset) *chainv1.Asset {
 	if asset == nil {
 		return nil
 	}
-	return &gatewayv1.Asset{
+	return &chainv1.Asset{
 		Chain:           asset.GetChain(),
 		TokenSymbol:     asset.GetTokenSymbol(),
 		ContractAddress: asset.GetContractAddress(),
@@ -358,11 +358,11 @@ func cloneFXQuote(quote *oraclev1.Quote) *oraclev1.Quote {
 	return nil
 }
 
-func cloneNetworkEstimate(resp *gatewayv1.EstimateTransferFeeResponse) *gatewayv1.EstimateTransferFeeResponse {
+func cloneNetworkEstimate(resp *chainv1.EstimateTransferFeeResponse) *chainv1.EstimateTransferFeeResponse {
 	if resp == nil {
 		return nil
 	}
-	if cloned, ok := proto.Clone(resp).(*gatewayv1.EstimateTransferFeeResponse); ok {
+	if cloned, ok := proto.Clone(resp).(*chainv1.EstimateTransferFeeResponse); ok {
 		return cloned
 	}
 	return nil

api/payments/orchestrator/internal/service/orchestrator/execution.go

@@ -10,7 +10,7 @@ import (
 	"github.com/tech/sendico/payments/orchestrator/storage/model"
 	"github.com/tech/sendico/pkg/merrors"
 	feesv1 "github.com/tech/sendico/pkg/proto/billing/fees/v1"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	ledgerv1 "github.com/tech/sendico/pkg/proto/ledger/v1"
 	oraclev1 "github.com/tech/sendico/pkg/proto/oracle/v1"
 	orchestratorv1 "github.com/tech/sendico/pkg/proto/payments/orchestrator/v1"
@@ -29,7 +29,7 @@ func (s *Service) buildPaymentQuote(ctx context.Context, orgRef string, req *orc
 	}
 	feeTotal := extractFeeTotal(feeQuote.GetLines(), amount.GetCurrency())
 
-	var networkFee *gatewayv1.EstimateTransferFeeResponse
+	var networkFee *chainv1.EstimateTransferFeeResponse
 	if shouldEstimateNetworkFee(intent) {
 		networkFee, err = s.estimateNetworkFee(ctx, intent)
 		if err != nil {
@@ -90,25 +90,25 @@ func (s *Service) quoteFees(ctx context.Context, orgRef string, req *orchestrato
 	return resp, nil
 }
 
-func (s *Service) estimateNetworkFee(ctx context.Context, intent *orchestratorv1.PaymentIntent) (*gatewayv1.EstimateTransferFeeResponse, error) {
+func (s *Service) estimateNetworkFee(ctx context.Context, intent *orchestratorv1.PaymentIntent) (*chainv1.EstimateTransferFeeResponse, error) {
 	if !s.gateway.available() {
 		return nil, nil
 	}
 
-	req := &gatewayv1.EstimateTransferFeeRequest{
+	req := &chainv1.EstimateTransferFeeRequest{
 		Amount: cloneMoney(intent.GetAmount()),
 	}
 	if src := intent.GetSource().GetManagedWallet(); src != nil {
 		req.SourceWalletRef = strings.TrimSpace(src.GetManagedWalletRef())
 	}
 	if dst := intent.GetDestination().GetManagedWallet(); dst != nil {
-		req.Destination = &gatewayv1.TransferDestination{
+		req.Destination = &chainv1.TransferDestination{
-			Destination: &gatewayv1.TransferDestination_ManagedWalletRef{ManagedWalletRef: strings.TrimSpace(dst.GetManagedWalletRef())},
+			Destination: &chainv1.TransferDestination_ManagedWalletRef{ManagedWalletRef: strings.TrimSpace(dst.GetManagedWalletRef())},
 		}
 	}
 	if dst := intent.GetDestination().GetExternalChain(); dst != nil {
-		req.Destination = &gatewayv1.TransferDestination{
+		req.Destination = &chainv1.TransferDestination{
-			Destination: &gatewayv1.TransferDestination_ExternalAddress{ExternalAddress: strings.TrimSpace(dst.GetAddress())},
+			Destination: &chainv1.TransferDestination_ExternalAddress{ExternalAddress: strings.TrimSpace(dst.GetAddress())},
 			Memo:        strings.TrimSpace(dst.GetMemo()),
 		}
 		req.Asset = dst.GetAsset()
@@ -320,7 +320,7 @@ func (s *Service) applyFX(ctx context.Context, payment *model.Payment, quote *or
 	return nil
 }
 
-func (s *Service) submitChainTransfer(ctx context.Context, payment *model.Payment, quote *orchestratorv1.PaymentQuote) (*gatewayv1.SubmitTransferResponse, error) {
+func (s *Service) submitChainTransfer(ctx context.Context, payment *model.Payment, quote *orchestratorv1.PaymentQuote) (*chainv1.SubmitTransferResponse, error) {
 	intent := payment.Intent
 	source := intent.Source.ManagedWallet
 	destination := intent.Destination
@@ -336,7 +336,7 @@ func (s *Service) submitChainTransfer(ctx context.Context, payment *model.Paymen
 		return nil, merrors.InvalidArgument("chain: amount is required")
 	}
 	fees := feeBreakdownFromQuote(quote)
-	req := &gatewayv1.SubmitTransferRequest{
+	req := &chainv1.SubmitTransferRequest{
 		IdempotencyKey:  payment.IdempotencyKey,
 		OrganizationRef: payment.OrganizationRef.Hex(),
 		SourceWalletRef: strings.TrimSpace(source.ManagedWalletRef),
@@ -437,21 +437,21 @@ func hasManagedWallet(endpoint model.PaymentEndpoint) bool {
 	return endpoint.Type == model.EndpointTypeManagedWallet && endpoint.ManagedWallet != nil && strings.TrimSpace(endpoint.ManagedWallet.ManagedWalletRef) != ""
 }
 
-func toGatewayDestination(endpoint model.PaymentEndpoint) (*gatewayv1.TransferDestination, error) {
+func toGatewayDestination(endpoint model.PaymentEndpoint) (*chainv1.TransferDestination, error) {
 	switch endpoint.Type {
 	case model.EndpointTypeManagedWallet:
 		if endpoint.ManagedWallet == nil || strings.TrimSpace(endpoint.ManagedWallet.ManagedWalletRef) == "" {
 			return nil, merrors.InvalidArgument("chain: destination managed wallet is required")
 		}
-		return &gatewayv1.TransferDestination{
+		return &chainv1.TransferDestination{
-			Destination: &gatewayv1.TransferDestination_ManagedWalletRef{ManagedWalletRef: strings.TrimSpace(endpoint.ManagedWallet.ManagedWalletRef)},
+			Destination: &chainv1.TransferDestination_ManagedWalletRef{ManagedWalletRef: strings.TrimSpace(endpoint.ManagedWallet.ManagedWalletRef)},
 		}, nil
 	case model.EndpointTypeExternalChain:
 		if endpoint.ExternalChain == nil || strings.TrimSpace(endpoint.ExternalChain.Address) == "" {
 			return nil, merrors.InvalidArgument("chain: external address is required")
 		}
-		return &gatewayv1.TransferDestination{
+		return &chainv1.TransferDestination{
-			Destination: &gatewayv1.TransferDestination_ExternalAddress{ExternalAddress: strings.TrimSpace(endpoint.ExternalChain.Address)},
+			Destination: &chainv1.TransferDestination_ExternalAddress{ExternalAddress: strings.TrimSpace(endpoint.ExternalChain.Address)},
 			Memo:        strings.TrimSpace(endpoint.ExternalChain.Memo),
 		}, nil
 	default:
@@ -459,7 +459,7 @@ func toGatewayDestination(endpoint model.PaymentEndpoint) (*gatewayv1.TransferDe
 	}
 }
 
-func applyTransferStatus(event *gatewayv1.TransferStatusChangedEvent, payment *model.Payment) {
+func applyTransferStatus(event *chainv1.TransferStatusChangedEvent, payment *model.Payment) {
 	if payment.Execution == nil {
 		payment.Execution = &model.ExecutionRefs{}
 	}
@@ -473,21 +473,21 @@ func applyTransferStatus(event *gatewayv1.TransferStatusChangedEvent, payment *m
 		reason = strings.TrimSpace(transfer.GetFailureReason())
 	}
 	switch transfer.GetStatus() {
-	case gatewayv1.TransferStatus_TRANSFER_CONFIRMED:
+	case chainv1.TransferStatus_TRANSFER_CONFIRMED:
 		payment.State = model.PaymentStateSettled
 		payment.FailureCode = model.PaymentFailureCodeUnspecified
 		payment.FailureReason = ""
-	case gatewayv1.TransferStatus_TRANSFER_FAILED:
+	case chainv1.TransferStatus_TRANSFER_FAILED:
 		payment.State = model.PaymentStateFailed
 		payment.FailureCode = model.PaymentFailureCodeChain
 		payment.FailureReason = reason
-	case gatewayv1.TransferStatus_TRANSFER_CANCELLED:
+	case chainv1.TransferStatus_TRANSFER_CANCELLED:
 		payment.State = model.PaymentStateCancelled
 		payment.FailureCode = model.PaymentFailureCodePolicy
 		payment.FailureReason = reason
-	case gatewayv1.TransferStatus_TRANSFER_SIGNING,
+	case chainv1.TransferStatus_TRANSFER_SIGNING,
-		gatewayv1.TransferStatus_TRANSFER_PENDING,
+		chainv1.TransferStatus_TRANSFER_PENDING,
-		gatewayv1.TransferStatus_TRANSFER_SUBMITTED:
+		chainv1.TransferStatus_TRANSFER_SUBMITTED:
 		payment.State = model.PaymentStateSubmitted
 	default:
 		// retain previous state

api/payments/orchestrator/internal/service/orchestrator/helpers.go

@@ -12,9 +12,9 @@ import (
 	"google.golang.org/protobuf/proto"
 
 	feesv1 "github.com/tech/sendico/pkg/proto/billing/fees/v1"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
 	accountingv1 "github.com/tech/sendico/pkg/proto/common/accounting/v1"
 	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 )
 
 func cloneMoney(input *moneyv1.Money) *moneyv1.Money {
@@ -108,7 +108,7 @@ func extractFeeTotal(lines []*feesv1.DerivedPostingLine, currency string) *money
 	}
 }
 
-func computeAggregates(base, fee *moneyv1.Money, network *gatewayv1.EstimateTransferFeeResponse) (*moneyv1.Money, *moneyv1.Money) {
+func computeAggregates(base, fee *moneyv1.Money, network *chainv1.EstimateTransferFeeResponse) (*moneyv1.Money, *moneyv1.Money) {
 	if base == nil {
 		return nil, nil
 	}
@@ -219,12 +219,12 @@ func ledgerLineTypeFromAccounting(lineType accountingv1.PostingLineType) ledgerv
 	}
 }
 
-func feeBreakdownFromQuote(quote *orchestratorv1.PaymentQuote) []*gatewayv1.ServiceFeeBreakdown {
+func feeBreakdownFromQuote(quote *orchestratorv1.PaymentQuote) []*chainv1.ServiceFeeBreakdown {
 	if quote == nil {
 		return nil
 	}
 	lines := quote.GetFeeLines()
-	breakdown := make([]*gatewayv1.ServiceFeeBreakdown, 0, len(lines)+1)
+	breakdown := make([]*chainv1.ServiceFeeBreakdown, 0, len(lines)+1)
 	for _, line := range lines {
 		if line == nil {
 			continue
@@ -241,7 +241,7 @@ func feeBreakdownFromQuote(quote *orchestratorv1.PaymentQuote) []*gatewayv1.Serv
 			code = line.GetLineType().String()
 		}
 		desc := strings.TrimSpace(line.GetMeta()["description"])
-		breakdown = append(breakdown, &gatewayv1.ServiceFeeBreakdown{
+		breakdown = append(breakdown, &chainv1.ServiceFeeBreakdown{
 			FeeCode:     code,
 			Amount:      amount,
 			Description: desc,
@@ -250,7 +250,7 @@ func feeBreakdownFromQuote(quote *orchestratorv1.PaymentQuote) []*gatewayv1.Serv
 	if quote.GetNetworkFee() != nil && quote.GetNetworkFee().GetNetworkFee() != nil {
 		networkAmount := cloneMoney(quote.GetNetworkFee().GetNetworkFee())
 		if networkAmount != nil {
-			breakdown = append(breakdown, &gatewayv1.ServiceFeeBreakdown{
+			breakdown = append(breakdown, &chainv1.ServiceFeeBreakdown{
 				FeeCode:     "network_fee",
 				Amount:      networkAmount,
 				Description: strings.TrimSpace(quote.GetNetworkFee().GetEstimationContext()),

api/payments/orchestrator/internal/service/orchestrator/options.go

@@ -3,7 +3,7 @@ package orchestrator
 import (
 	"time"
 
-	chainclient "github.com/tech/sendico/chain/gateway/client"
+	chainclient "github.com/tech/sendico/gateway/chain/client"
 	oracleclient "github.com/tech/sendico/fx/oracle/client"
 	ledgerclient "github.com/tech/sendico/ledger/client"
 	clockpkg "github.com/tech/sendico/pkg/clock"

api/payments/orchestrator/internal/service/orchestrator/service_test.go

@@ -7,14 +7,14 @@ import (
 	"testing"
 	"time"
 
-	chainclient "github.com/tech/sendico/chain/gateway/client"
+	chainclient "github.com/tech/sendico/gateway/chain/client"
 	ledgerclient "github.com/tech/sendico/ledger/client"
 	"github.com/tech/sendico/payments/orchestrator/storage"
 	"github.com/tech/sendico/payments/orchestrator/storage/model"
 	"github.com/tech/sendico/pkg/api/routers/gsresponse"
 	mo "github.com/tech/sendico/pkg/model"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
 	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	ledgerv1 "github.com/tech/sendico/pkg/proto/ledger/v1"
 	oraclev1 "github.com/tech/sendico/pkg/proto/oracle/v1"
 	orchestratorv1 "github.com/tech/sendico/pkg/proto/payments/orchestrator/v1"
@@ -88,7 +88,7 @@ func TestExecutePayment_ChainFailure(t *testing.T) {
 		clock:   testClock{now: time.Now()},
 		storage: repo,
 		gateway: gatewayDependency{client: &chainclient.Fake{
-			SubmitTransferFn: func(ctx context.Context, req *gatewayv1.SubmitTransferRequest) (*gatewayv1.SubmitTransferResponse, error) {
+			SubmitTransferFn: func(ctx context.Context, req *chainv1.SubmitTransferRequest) (*chainv1.SubmitTransferResponse, error) {
 				return nil, errors.New("chain failure")
 			},
 		}},
@@ -147,10 +147,10 @@ func TestProcessTransferUpdateHandler_Settled(t *testing.T) {
 	}
 
 	req := &orchestratorv1.ProcessTransferUpdateRequest{
-		Event: &gatewayv1.TransferStatusChangedEvent{
+		Event: &chainv1.TransferStatusChangedEvent{
-			Transfer: &gatewayv1.Transfer{
+			Transfer: &chainv1.Transfer{
 				TransferRef: "transfer-1",
-				Status:      gatewayv1.TransferStatus_TRANSFER_CONFIRMED,
+				Status:      chainv1.TransferStatus_TRANSFER_CONFIRMED,
 			},
 		},
 	}
@@ -190,7 +190,7 @@ func TestProcessDepositObservedHandler_MatchesPayment(t *testing.T) {
 	}
 
 	req := &orchestratorv1.ProcessDepositObservedRequest{
-		Event: &gatewayv1.WalletDepositObservedEvent{
+		Event: &chainv1.WalletDepositObservedEvent{
 			WalletRef: "wallet-dst",
 			Amount:    &moneyv1.Money{Currency: "USD", Amount: "40"},
 		},

api/payments/orchestrator/storage/model/payment.go

@@ -7,9 +7,9 @@ import (
 	"github.com/tech/sendico/pkg/model"
 	"github.com/tech/sendico/pkg/mservice"
 	feesv1 "github.com/tech/sendico/pkg/proto/billing/fees/v1"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
 	fxv1 "github.com/tech/sendico/pkg/proto/common/fx/v1"
 	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	oraclev1 "github.com/tech/sendico/pkg/proto/oracle/v1"
 )
 
@@ -67,15 +67,15 @@ type LedgerEndpoint struct {
 
 // ManagedWalletEndpoint describes managed wallet routing.
 type ManagedWalletEndpoint struct {
-	ManagedWalletRef string           `bson:"managedWalletRef" json:"managedWalletRef"`
+	ManagedWalletRef string         `bson:"managedWalletRef" json:"managedWalletRef"`
-	Asset            *gatewayv1.Asset `bson:"asset,omitempty" json:"asset,omitempty"`
+	Asset            *chainv1.Asset `bson:"asset,omitempty" json:"asset,omitempty"`
 }
 
 // ExternalChainEndpoint describes an external address.
 type ExternalChainEndpoint struct {
-	Asset   *gatewayv1.Asset `bson:"asset,omitempty" json:"asset,omitempty"`
+	Asset   *chainv1.Asset `bson:"asset,omitempty" json:"asset,omitempty"`
-	Address string           `bson:"address" json:"address"`
+	Address string         `bson:"address" json:"address"`
-	Memo    string           `bson:"memo,omitempty" json:"memo,omitempty"`
+	Memo    string         `bson:"memo,omitempty" json:"memo,omitempty"`
 }
 
 // PaymentEndpoint is a polymorphic payment destination/source.
@@ -111,14 +111,14 @@ type PaymentIntent struct {
 
 // PaymentQuoteSnapshot stores the latest quote info.
 type PaymentQuoteSnapshot struct {
-	DebitAmount              *moneyv1.Money                         `bson:"debitAmount,omitempty" json:"debitAmount,omitempty"`
+	DebitAmount              *moneyv1.Money                       `bson:"debitAmount,omitempty" json:"debitAmount,omitempty"`
-	ExpectedSettlementAmount *moneyv1.Money                         `bson:"expectedSettlementAmount,omitempty" json:"expectedSettlementAmount,omitempty"`
+	ExpectedSettlementAmount *moneyv1.Money                       `bson:"expectedSettlementAmount,omitempty" json:"expectedSettlementAmount,omitempty"`
-	ExpectedFeeTotal         *moneyv1.Money                         `bson:"expectedFeeTotal,omitempty" json:"expectedFeeTotal,omitempty"`
+	ExpectedFeeTotal         *moneyv1.Money                       `bson:"expectedFeeTotal,omitempty" json:"expectedFeeTotal,omitempty"`
-	FeeLines                 []*feesv1.DerivedPostingLine           `bson:"feeLines,omitempty" json:"feeLines,omitempty"`
+	FeeLines                 []*feesv1.DerivedPostingLine         `bson:"feeLines,omitempty" json:"feeLines,omitempty"`
-	FeeRules                 []*feesv1.AppliedRule                  `bson:"feeRules,omitempty" json:"feeRules,omitempty"`
+	FeeRules                 []*feesv1.AppliedRule                `bson:"feeRules,omitempty" json:"feeRules,omitempty"`
-	FXQuote                  *oraclev1.Quote                        `bson:"fxQuote,omitempty" json:"fxQuote,omitempty"`
+	FXQuote                  *oraclev1.Quote                      `bson:"fxQuote,omitempty" json:"fxQuote,omitempty"`
-	NetworkFee               *gatewayv1.EstimateTransferFeeResponse `bson:"networkFee,omitempty" json:"networkFee,omitempty"`
+	NetworkFee               *chainv1.EstimateTransferFeeResponse `bson:"networkFee,omitempty" json:"networkFee,omitempty"`
-	FeeQuoteToken            string                                 `bson:"feeQuoteToken,omitempty" json:"feeQuoteToken,omitempty"`
+	FeeQuoteToken            string                               `bson:"feeQuoteToken,omitempty" json:"feeQuoteToken,omitempty"`
 }
 
 // ExecutionRefs links to downstream systems.

api/pkg/.gitignore

@@ -1,6 +1,8 @@
 proto/billing
 proto/common
 proto/chain
+proto/gateway
 proto/ledger
 proto/oracle
-proto/payments
+proto/payments
+.gocache

api/pkg/model/crypto_address.go

@@ -0,0 +1,27 @@
+package model
+
+import (
+	"fmt"
+
+	"github.com/tech/sendico/pkg/merrors"
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+type CryptoAddressPaymentData struct {
+	Address        string  `bson:"address" json:"address"`
+	Network        string  `bson:"network" json:"network"`
+	DestinationTag *string `bson:"destinationTag,omitempty" json:"destinationTag,omitempty"`
+}
+
+func (m *PaymentMethod) AsCryptoAddress() (*CryptoAddressPaymentData, error) {
+	if m.Type != PaymentTypeCryptoAddress {
+		return nil, merrors.InvalidArgument(fmt.Sprintf("payment method type is %s, not cryptoAddress", m.Type), "type")
+	}
+
+	var d CryptoAddressPaymentData
+	if err := bson.Unmarshal(m.Data, &d); err != nil {
+		return nil, err
+	}
+
+	return &d, nil
+}

api/pkg/model/payment.go

@@ -16,20 +16,23 @@ const (
 	PaymentTypeCard
 	PaymentTypeBankAccount
 	PaymentTypeWallet
+	PaymentTypeCryptoAddress
 )
 
 var paymentTypeToString = map[PaymentType]string{
-	PaymentTypeIban:        "iban",
+	PaymentTypeIban:          "iban",
-	PaymentTypeCard:        "card",
+	PaymentTypeCard:          "card",
-	PaymentTypeBankAccount: "bankAccount",
+	PaymentTypeBankAccount:   "bankAccount",
-	PaymentTypeWallet:      "wallet",
+	PaymentTypeWallet:        "wallet",
+	PaymentTypeCryptoAddress: "cryptoAddress",
 }
 
 var paymentTypeFromString = map[string]PaymentType{
-	"iban":        PaymentTypeIban,
+	"iban":          PaymentTypeIban,
-	"card":        PaymentTypeCard,
+	"card":          PaymentTypeCard,
-	"bankAccount": PaymentTypeBankAccount,
+	"bankAccount":   PaymentTypeBankAccount,
-	"wallet":      PaymentTypeWallet,
+	"wallet":        PaymentTypeWallet,
+	"cryptoAddress": PaymentTypeCryptoAddress,
 }
 
 func (t PaymentType) String() string {
@@ -61,6 +64,5 @@ type PaymentMethod struct {
 
 	RecipientRef primitive.ObjectID `bson:"recipientRef" json:"recipientRef"`
 	Type         PaymentType        `bson:"type" json:"type"`
-	IsActive     bool               `bson:"isActive" json:"isActive"`
 	Data         bson.Raw           `bson:"data" json:"data"`
 }

api/proto/common/gateway/v1/gateway.proto

@@ -0,0 +1,97 @@
+syntax = "proto3";
+package common.gateway.v1;
+option go_package = "github.com/tech/sendico/pkg/proto/common/gateway/v1;gatewayv1";
+
+enum Operation {
+  OPERATION_UNSPECIFIED     = 0;
+  OPERATION_AUTHORIZE       = 1;
+  OPERATION_CAPTURE         = 2;
+  OPERATION_REFUND          = 3;
+  OPERATION_VOID            = 4;
+  OPERATION_PAYOUT          = 5;
+  OPERATION_TOKENIZE        = 6;
+  OPERATION_VERIFY          = 7; // zero-amount verification
+  OPERATION_GET_BALANCE     = 8;
+  OPERATION_CREATE_ACCOUNT  = 9;
+}
+
+enum PaymentMethodType {
+  PM_UNSPECIFIED = 0;
+  PM_CARD        = 1;
+  PM_SEPA        = 2;
+  PM_ACH         = 3;
+  PM_PIX         = 4;
+  PM_WALLET      = 5;
+  PM_CRYPTO      = 6;
+  PM_LOCAL_BANK  = 7; // generic local rails, refine later if needed
+}
+
+// Limits in minor units, e.g. cents
+message AmountLimits {
+  int64 min_minor = 1;
+  int64 max_minor = 2;
+}
+
+// Capabilities of a particular operation (e.g. "authorize")
+message OperationCapabilities {
+  // If false or absent in the map -> operation not supported
+  bool supported        = 1;
+  bool partial_allowed  = 2; // partial capture/refund
+  bool supports_3ds     = 3; // relevant mostly for AUTHORIZE/VERIFY
+  bool synchronous      = 4; // true = immediate result, false = async/poll
+}
+
+// Per-method matrix entry
+message MethodCapability {
+  PaymentMethodType method     = 1;
+
+  // ISO 4217 currency codes, e.g. "EUR", "USD"
+  repeated string currencies   = 2;
+
+  // ISO 3166-1 alpha-2 country codes where this method is available
+  repeated string countries    = 3;
+
+  // Can the gateway tokenize this method (card token, wallet token, etc.)
+  bool tokenization_supported  = 4;
+
+  // Optional per-method limits; if unset, use global amount_limits
+  AmountLimits amount_limits   = 5;
+}
+
+// Payout capabilities of this gateway
+message PayoutCapabilities {
+  bool enabled                  = 1;
+  repeated string currencies    = 2;
+  repeated string countries     = 3;
+  AmountLimits amount_limits    = 4;
+}
+
+// High-level capability descriptor for a gateway
+message GatewayCapabilities {
+  // For each operation, describe what exactly it can do.
+  // Map key uses the Operation enum name (e.g. "OPERATION_AUTHORIZE").
+  map<string, OperationCapabilities> operations = 1;
+
+  // For each payment method, list where and how it works
+  repeated MethodCapability methods = 2;
+
+  // Global amount limits (fallback if per-method limits not set)
+  AmountLimits amount_limits = 3;
+
+  // Payout-related capabilities (if any)
+  PayoutCapabilities payouts = 4;
+
+  // Free-form metadata / escape hatch
+  map<string, string> extra = 10;
+}
+
+// A specific gateway instance or config variant (e.g. stripe_eu_prod)
+message GatewayDescriptor {
+  string id          = 1; // "stripe_eu", "adyen_br", "local_bank_pl"
+  string provider    = 2; // "stripe", "adyen", "local_bank"
+  string label       = 3; // human-readable name
+  string version     = 4; // config or integration version
+  string environment = 5; // "prod", "sandbox", "test"
+
+  GatewayCapabilities capabilities = 6;
+}

api/proto/gateway/chain/v1/chain.proto

@@ -2,7 +2,7 @@ syntax = "proto3";
 
 package chain.gateway.v1;
 
-option go_package = "github.com/tech/sendico/pkg/proto/chain/gateway/v1;gatewayv1";
+option go_package = "github.com/tech/sendico/pkg/proto/gateway/chain/v1;chainv1";
 
 import "google/protobuf/timestamp.proto";
 import "common/money/v1/money.proto";
@@ -198,7 +198,7 @@ message WalletDepositObservedEvent {
 
 message TransferStatusChangedEvent {
   Transfer transfer = 1;
-  string reason = 2;
+  string reason = 2;             
 }
 
 service ChainGatewayService {

api/proto/payments/orchestrator/v1/orchestrator.proto

@@ -10,7 +10,7 @@ import "common/fx/v1/fx.proto";
 import "common/trace/v1/trace.proto";
 import "common/pagination/v1/cursor.proto";
 import "billing/fees/v1/fees.proto";
-import "chain/gateway/v1/gateway.proto";
+import "gateway/chain/v1/chain.proto";
 import "oracle/v1/oracle.proto";
 
 enum PaymentKind {

api/server/.gitignore

@@ -1,3 +1,4 @@
 /app
 /server
 /storage
+.gocache

api/server/go.mod

@@ -6,7 +6,7 @@ replace github.com/tech/sendico/pkg => ../pkg
 
 replace github.com/tech/sendico/ledger => ../ledger
 
-replace github.com/tech/sendico/chain/gateway => ../chain/gateway
+replace github.com/tech/sendico/gateway/chain => ../gateway/chain
 
 require (
 	github.com/aws/aws-sdk-go-v2 v1.40.0
@@ -20,7 +20,7 @@ require (
 	github.com/google/uuid v1.6.0
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/stretchr/testify v1.11.1
-	github.com/tech/sendico/chain/gateway v0.1.0
+	github.com/tech/sendico/gateway/chain v0.1.0
 	github.com/tech/sendico/ledger v0.0.0-00010101000000-000000000000
 	github.com/tech/sendico/pkg v0.1.0
 	github.com/testcontainers/testcontainers-go v0.33.0

api/server/interface/api/srequest/signup.go

@@ -1,6 +1,11 @@
 package srequest
 
-import "github.com/tech/sendico/pkg/model"
+import (
+	"bytes"
+	"encoding/json"
+
+	"github.com/tech/sendico/pkg/model"
+)
 
 type Signup struct {
 	Account              model.AccountData `json:"account"`
@@ -8,3 +13,17 @@ type Signup struct {
 	OrganizationTimeZone string            `json:"organizationTimeZone"`
 	OwnerRole            model.Describable `json:"ownerRole"`
 }
+
+// UnmarshalJSON enforces strict parsing to catch malformed or unexpected fields.
+func (s *Signup) UnmarshalJSON(data []byte) error {
+	type alias Signup
+	var payload alias
+
+	dec := json.NewDecoder(bytes.NewReader(data))
+	dec.DisallowUnknownFields()
+	if err := dec.Decode(&payload); err != nil {
+		return err
+	}
+	*s = Signup(payload)
+	return nil
+}

api/server/interface/api/sresponse/wallet.go

@@ -6,9 +6,9 @@ import (
 
 	"github.com/tech/sendico/pkg/api/http/response"
 	"github.com/tech/sendico/pkg/mlogger"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
 	moneyv1 "github.com/tech/sendico/pkg/proto/common/money/v1"
 	paginationv1 "github.com/tech/sendico/pkg/proto/common/pagination/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
@@ -53,7 +53,7 @@ type walletBalanceResponse struct {
 	Balance      walletBalance `json:"balance"`
 }
 
-func Wallets(logger mlogger.Logger, resp *gatewayv1.ListManagedWalletsResponse, accessToken *TokenData) http.HandlerFunc {
+func Wallets(logger mlogger.Logger, resp *chainv1.ListManagedWalletsResponse, accessToken *TokenData) http.HandlerFunc {
 	dto := walletsResponse{
 		Page:         resp.GetPage(),
 		authResponse: authResponse{AccessToken: *accessToken},
@@ -65,14 +65,14 @@ func Wallets(logger mlogger.Logger, resp *gatewayv1.ListManagedWalletsResponse,
 	return response.Ok(logger, dto)
 }
 
-func WalletBalance(logger mlogger.Logger, bal *gatewayv1.WalletBalance, accessToken *TokenData) http.HandlerFunc {
+func WalletBalance(logger mlogger.Logger, bal *chainv1.WalletBalance, accessToken *TokenData) http.HandlerFunc {
 	return response.Ok(logger, walletBalanceResponse{
 		Balance:      toWalletBalance(bal),
 		authResponse: authResponse{AccessToken: *accessToken},
 	})
 }
 
-func toWallet(w *gatewayv1.ManagedWallet) wallet {
+func toWallet(w *chainv1.ManagedWallet) wallet {
 	if w == nil {
 		return wallet{}
 	}
@@ -102,7 +102,7 @@ func toWallet(w *gatewayv1.ManagedWallet) wallet {
 	}
 }
 
-func toWalletBalance(b *gatewayv1.WalletBalance) walletBalance {
+func toWalletBalance(b *chainv1.WalletBalance) walletBalance {
 	if b == nil {
 		return walletBalance{}
 	}

api/server/internal/server/accountapiimp/service.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"time"
 
-	chaingatewayclient "github.com/tech/sendico/chain/gateway/client"
+	chaingatewayclient "github.com/tech/sendico/gateway/chain/client"
 	api "github.com/tech/sendico/pkg/api/http"
 	"github.com/tech/sendico/pkg/auth"
 	"github.com/tech/sendico/pkg/db/account"
@@ -20,7 +20,7 @@ import (
 	"github.com/tech/sendico/pkg/messaging"
 	"github.com/tech/sendico/pkg/mlogger"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"github.com/tech/sendico/server/interface/accountservice"
 	eapi "github.com/tech/sendico/server/interface/api"
 	"github.com/tech/sendico/server/interface/services/fileservice"
@@ -47,11 +47,11 @@ type AccountAPI struct {
 	accountsPermissionRef primitive.ObjectID
 	accService            accountservice.AccountService
 	chainGateway          chainWalletClient
-	chainAsset            *gatewayv1.Asset
+	chainAsset            *chainv1.Asset
 }
 
 type chainWalletClient interface {
-	CreateManagedWallet(ctx context.Context, req *gatewayv1.CreateManagedWalletRequest) (*gatewayv1.CreateManagedWalletResponse, error)
+	CreateManagedWallet(ctx context.Context, req *chainv1.CreateManagedWalletRequest) (*chainv1.CreateManagedWalletResponse, error)
 	Close() error
 }
 
@@ -192,7 +192,7 @@ func (a *AccountAPI) initChainGateway(cfg *eapi.ChainGatewayConfig) error {
 	return nil
 }
 
-func buildGatewayAsset(cfg eapi.ChainGatewayAssetConfig) (*gatewayv1.Asset, error) {
+func buildGatewayAsset(cfg eapi.ChainGatewayAssetConfig) (*chainv1.Asset, error) {
 	chain, err := parseChainNetwork(cfg.Chain)
 	if err != nil {
 		return nil, err
@@ -201,24 +201,24 @@ func buildGatewayAsset(cfg eapi.ChainGatewayAssetConfig) (*gatewayv1.Asset, erro
 	if tokenSymbol == "" {
 		return nil, merrors.InvalidArgument("chain gateway token symbol is required")
 	}
-	return &gatewayv1.Asset{
+	return &chainv1.Asset{
 		Chain:           chain,
 		TokenSymbol:     strings.ToUpper(tokenSymbol),
 		ContractAddress: strings.ToLower(strings.TrimSpace(cfg.ContractAddress)),
 	}, nil
 }
 
-func parseChainNetwork(value string) (gatewayv1.ChainNetwork, error) {
+func parseChainNetwork(value string) (chainv1.ChainNetwork, error) {
 	switch strings.ToUpper(strings.TrimSpace(value)) {
 	case "ETHEREUM_MAINNET", "CHAIN_NETWORK_ETHEREUM_MAINNET":
-		return gatewayv1.ChainNetwork_CHAIN_NETWORK_ETHEREUM_MAINNET, nil
+		return chainv1.ChainNetwork_CHAIN_NETWORK_ETHEREUM_MAINNET, nil
 	case "ARBITRUM_ONE", "CHAIN_NETWORK_ARBITRUM_ONE":
-		return gatewayv1.ChainNetwork_CHAIN_NETWORK_ARBITRUM_ONE, nil
+		return chainv1.ChainNetwork_CHAIN_NETWORK_ARBITRUM_ONE, nil
 	case "OTHER_EVM", "CHAIN_NETWORK_OTHER_EVM":
-		return gatewayv1.ChainNetwork_CHAIN_NETWORK_OTHER_EVM, nil
+		return chainv1.ChainNetwork_CHAIN_NETWORK_OTHER_EVM, nil
 	case "", "CHAIN_NETWORK_UNSPECIFIED":
-		return gatewayv1.ChainNetwork_CHAIN_NETWORK_UNSPECIFIED, merrors.InvalidArgument("chain network must be specified")
+		return chainv1.ChainNetwork_CHAIN_NETWORK_UNSPECIFIED, merrors.InvalidArgument("chain network must be specified")
 	default:
-		return gatewayv1.ChainNetwork_CHAIN_NETWORK_UNSPECIFIED, merrors.InvalidArgument(fmt.Sprintf("unsupported chain network %s", value))
+		return chainv1.ChainNetwork_CHAIN_NETWORK_UNSPECIFIED, merrors.InvalidArgument(fmt.Sprintf("unsupported chain network %s", value))
 	}
 }

api/server/internal/server/accountapiimp/signup.go

@@ -16,7 +16,7 @@ import (
 	"github.com/tech/sendico/pkg/model"
 	"github.com/tech/sendico/pkg/mservice"
 	"github.com/tech/sendico/pkg/mutil/mzap"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"github.com/tech/sendico/server/interface/api/srequest"
 	"github.com/tech/sendico/server/interface/api/sresponse"
 	"go.mongodb.org/mongo-driver/bson/primitive"
@@ -249,7 +249,7 @@ func (a *AccountAPI) openOrgWallet(ctx context.Context, org *model.Organization,
 		return merrors.Internal("chain gateway client is not configured")
 	}
 	asset := *a.chainAsset
-	req := &gatewayv1.CreateManagedWalletRequest{
+	req := &chainv1.CreateManagedWalletRequest{
 		IdempotencyKey:  uuid.NewString(),
 		OrganizationRef: org.ID.Hex(),
 		OwnerRef:        org.ID.Hex(),

api/server/internal/server/accountapiimp/signup_integration_test.go

@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
+	"os"
 	"testing"
 	"time"
 
@@ -27,6 +28,10 @@ func stringPtr(s string) *string {
 
 // TestSignupRequestSerialization tests JSON marshaling/unmarshaling with real MongoDB
 func TestSignupRequestSerialization(t *testing.T) {
+	if os.Getenv("RUN_DOCKER_TESTS") == "" {
+		t.Skip("skipping: docker-dependent integration test (set RUN_DOCKER_TESTS=1 to enable)")
+	}
+
 	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
 	defer cancel()
 

api/server/internal/server/walletapiimp/balance.go

@@ -8,7 +8,7 @@ import (
 	"github.com/tech/sendico/pkg/api/http/response"
 	"github.com/tech/sendico/pkg/model"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"github.com/tech/sendico/server/interface/api/sresponse"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.uber.org/zap"
@@ -39,7 +39,7 @@ func (a *WalletAPI) getWalletBalance(r *http.Request, account *model.Account, to
 		return response.Internal(a.logger, mservice.ChainGateway, errors.New("chain gateway client is not configured"))
 	}
 
-	resp, err := a.chainGateway.GetWalletBalance(ctx, &gatewayv1.GetWalletBalanceRequest{WalletRef: walletRef})
+	resp, err := a.chainGateway.GetWalletBalance(ctx, &chainv1.GetWalletBalanceRequest{WalletRef: walletRef})
 	if err != nil {
 		a.logger.Warn("Failed to fetch wallet balance", zap.Error(err), zap.String("wallet_ref", walletRef))
 		return response.Auto(a.logger, mservice.ChainGateway, err)

api/server/internal/server/walletapiimp/list.go

@@ -8,7 +8,7 @@ import (
 	"github.com/tech/sendico/pkg/api/http/response"
 	"github.com/tech/sendico/pkg/model"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	"github.com/tech/sendico/server/interface/api/sresponse"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.uber.org/zap"
@@ -35,7 +35,7 @@ func (a *WalletAPI) listWallets(r *http.Request, account *model.Account, token *
 		return response.Internal(a.logger, mservice.ChainGateway, errors.New("chain gateway client is not configured"))
 	}
 
-	req := &gatewayv1.ListManagedWalletsRequest{
+	req := &chainv1.ListManagedWalletsRequest{
 		OrganizationRef: orgRef.Hex(),
 	}
 	if owner := strings.TrimSpace(r.URL.Query().Get("owner_ref")); owner != "" {

api/server/internal/server/walletapiimp/service.go

@@ -7,13 +7,13 @@ import (
 	"strings"
 	"time"
 
-	chaingatewayclient "github.com/tech/sendico/chain/gateway/client"
+	chaingatewayclient "github.com/tech/sendico/gateway/chain/client"
 	api "github.com/tech/sendico/pkg/api/http"
 	"github.com/tech/sendico/pkg/auth"
 	"github.com/tech/sendico/pkg/merrors"
 	"github.com/tech/sendico/pkg/mlogger"
 	"github.com/tech/sendico/pkg/mservice"
-	gatewayv1 "github.com/tech/sendico/pkg/proto/chain/gateway/v1"
+	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	eapi "github.com/tech/sendico/server/interface/api"
 	mutil "github.com/tech/sendico/server/internal/mutil/param"
 	"go.mongodb.org/mongo-driver/bson/primitive"
@@ -31,8 +31,8 @@ type WalletAPI struct {
 }
 
 type chainWalletClient interface {
-	ListManagedWallets(ctx context.Context, req *gatewayv1.ListManagedWalletsRequest) (*gatewayv1.ListManagedWalletsResponse, error)
+	ListManagedWallets(ctx context.Context, req *chainv1.ListManagedWalletsRequest) (*chainv1.ListManagedWalletsResponse, error)
-	GetWalletBalance(ctx context.Context, req *gatewayv1.GetWalletBalanceRequest) (*gatewayv1.GetWalletBalanceResponse, error)
+	GetWalletBalance(ctx context.Context, req *chainv1.GetWalletBalanceRequest) (*chainv1.GetWalletBalanceResponse, error)
 	Close() error
 }
 

ci/prod/compose/chain_gateway.dockerfile

@@ -17,25 +17,25 @@ RUN apk add --no-cache bash git build-base protoc protobuf-dev \
  && go install google.golang.org/protobuf/cmd/protoc-gen-go@latest \
  && go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest \
  && bash ci/scripts/proto/generate.sh
-WORKDIR /src/api/chain/gateway
+WORKDIR /src/api/gateway/chain
 RUN --mount=type=cache,target=/root/.cache/go-build \
     --mount=type=cache,target=/go/pkg/mod \
     CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} \
     go build -trimpath -ldflags "\
       -s -w \
-      -X github.com/tech/sendico/chain/gateway/internal/appversion.Version=${APP_VERSION} \
+      -X github.com/tech/sendico/gateway/chain/internal/appversion.Version=${APP_VERSION} \
-      -X github.com/tech/sendico/chain/gateway/internal/appversion.Revision=${GIT_REV} \
+      -X github.com/tech/sendico/gateway/chain/internal/appversion.Revision=${GIT_REV} \
-      -X github.com/tech/sendico/chain/gateway/internal/appversion.Branch=${BUILD_BRANCH} \
+      -X github.com/tech/sendico/gateway/chain/internal/appversion.Branch=${BUILD_BRANCH} \
-      -X github.com/tech/sendico/chain/gateway/internal/appversion.BuildUser=${BUILD_USER} \
+      -X github.com/tech/sendico/gateway/chain/internal/appversion.BuildUser=${BUILD_USER} \
-      -X github.com/tech/sendico/chain/gateway/internal/appversion.BuildDate=${BUILD_DATE}" \
+      -X github.com/tech/sendico/gateway/chain/internal/appversion.BuildDate=${BUILD_DATE}" \
     -o /out/chain-gateway .
 
 FROM alpine:latest AS runtime
 RUN apk add --no-cache ca-certificates tzdata wget
 WORKDIR /app
-COPY api/chain/gateway/config.yml /app/config.yml
+COPY api/gateway/chain/config.yml /app/config.yml
-COPY api/chain/gateway/env /app/env
+COPY api/gateway/chain/env /app/env
-COPY api/chain/gateway/entrypoint.sh /app/entrypoint.sh
+COPY api/gateway/chain/entrypoint.sh /app/entrypoint.sh
 COPY --from=build /out/chain-gateway /app/chain-gateway
 RUN chmod +x /app/entrypoint.sh
 EXPOSE 50070 9403

ci/prod/compose/chain_gateway.yml

@@ -23,7 +23,7 @@ services:
     <<: *common-env
     container_name: sendico-chain-gateway
     restart: unless-stopped
-    image: ${REGISTRY_URL}/chain/gateway:${APP_V}
+    image: ${REGISTRY_URL}/gateway/chain:${APP_V}
     pull_policy: always
     environment:
       CHAIN_GATEWAY_MONGO_HOST: ${CHAIN_GATEWAY_MONGO_HOST}

ci/scripts/proto/generate.sh

@@ -104,10 +104,10 @@ if [ -f "${PROTO_DIR}/oracle/v1/oracle.proto" ]; then
   generate_go_with_grpc "${PROTO_DIR}/oracle/v1/oracle.proto"
 fi
 
-if [ -f "${PROTO_DIR}/chain/gateway/v1/gateway.proto" ]; then
+if [ -f "${PROTO_DIR}/gateway/chain/v1/chain.proto" ]; then
   info "Compiling chain gateway protos"
-  clean_pb_files "./pkg/proto/chain/gateway"
+  clean_pb_files "./pkg/proto/gateway/chain"
-  generate_go_with_grpc "${PROTO_DIR}/chain/gateway/v1/gateway.proto"
+  generate_go_with_grpc "${PROTO_DIR}/gateway/chain/v1/chain.proto"
 fi
 
 if [ -f "${PROTO_DIR}/payments/orchestrator/v1/orchestrator.proto" ]; then

frontend/pshared/lib/data/dto/payment/card.dart

@@ -0,0 +1,20 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'card.g.dart';
+
+
+@JsonSerializable()
+class CardPaymentDataDTO {
+  final String pan;
+  final String firstName;
+  final String lastName;
+
+  const CardPaymentDataDTO({
+    required this.pan,
+    required this.firstName,
+    required this.lastName,
+  });
+
+  factory CardPaymentDataDTO.fromJson(Map<String, dynamic> json) => _$CardPaymentDataDTOFromJson(json);
+  Map<String, dynamic> toJson() => _$CardPaymentDataDTOToJson(this);
+}

frontend/pshared/lib/data/dto/payment/crypto_address.dart

@@ -0,0 +1,20 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'crypto_address.g.dart';
+
+
+@JsonSerializable()
+class CryptoAddressPaymentDataDTO {
+  final String address;
+  final String network;
+  final String? destinationTag;
+
+  const CryptoAddressPaymentDataDTO({
+    required this.address,
+    required this.network,
+    this.destinationTag,
+  });
+
+  factory CryptoAddressPaymentDataDTO.fromJson(Map<String, dynamic> json) => _$CryptoAddressPaymentDataDTOFromJson(json);
+  Map<String, dynamic> toJson() => _$CryptoAddressPaymentDataDTOToJson(this);
+}

frontend/pshared/lib/data/dto/payment/iban.dart

@@ -0,0 +1,22 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'iban.g.dart';
+
+
+@JsonSerializable()
+class IbanPaymentDataDTO {
+  final String iban;
+  final String accountHolder;
+  final String? bic;
+  final String? bankName;
+
+  const IbanPaymentDataDTO({
+    required this.iban,
+    required this.accountHolder,
+    this.bic,
+    this.bankName,
+  });
+
+  factory IbanPaymentDataDTO.fromJson(Map<String, dynamic> json) => _$IbanPaymentDataDTOFromJson(json);
+  Map<String, dynamic> toJson() => _$IbanPaymentDataDTOToJson(this);
+}

frontend/pshared/lib/data/dto/payment/method.dart

@@ -0,0 +1,33 @@
+import 'package:json_annotation/json_annotation.dart';
+
+import 'package:pshared/data/dto/date_time.dart';
+import 'package:pshared/data/dto/permissions/bound.dart';
+
+part 'method.g.dart';
+
+
+@JsonSerializable()
+class PaymentMethodDTO extends PermissionBoundDTO {
+  final String recipientRef;
+  final String type;
+  final Map<String, dynamic> data;
+
+  @JsonKey(defaultValue: false)
+  final bool isArchived;
+
+  const PaymentMethodDTO({
+    required super.id,
+    required super.createdAt,
+    required super.updatedAt,
+    required super.permissionRef,
+    required super.organizationRef,
+    required this.recipientRef,
+    required this.type,
+    required this.data,
+    this.isArchived = false,
+  });
+
+  factory PaymentMethodDTO.fromJson(Map<String, dynamic> json) => _$PaymentMethodDTOFromJson(json);
+  @override
+  Map<String, dynamic> toJson() => _$PaymentMethodDTOToJson(this);
+}

frontend/pshared/lib/data/dto/payment/russian_bank.dart

@@ -0,0 +1,28 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'russian_bank.g.dart';
+
+
+@JsonSerializable()
+class RussianBankAccountPaymentDataDTO {
+  final String recipientName;
+  final String inn;
+  final String kpp;
+  final String bankName;
+  final String bik;
+  final String accountNumber;
+  final String correspondentAccount;
+
+  const RussianBankAccountPaymentDataDTO({
+    required this.recipientName,
+    required this.inn,
+    required this.kpp,
+    required this.bankName,
+    required this.bik,
+    required this.accountNumber,
+    required this.correspondentAccount,
+  });
+
+  factory RussianBankAccountPaymentDataDTO.fromJson(Map<String, dynamic> json) => _$RussianBankAccountPaymentDataDTOFromJson(json);
+  Map<String, dynamic> toJson() => _$RussianBankAccountPaymentDataDTOToJson(this);
+}

frontend/pshared/lib/data/dto/payment/wallet.dart

@@ -0,0 +1,16 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'wallet.g.dart';
+
+
+@JsonSerializable()
+class WalletPaymentDataDTO {
+  final String walletId;
+
+  const WalletPaymentDataDTO({
+    required this.walletId,
+  });
+
+  factory WalletPaymentDataDTO.fromJson(Map<String, dynamic> json) => _$WalletPaymentDataDTOFromJson(json);
+  Map<String, dynamic> toJson() => _$WalletPaymentDataDTOToJson(this);
+}

frontend/pshared/lib/data/dto/recipient/recipient.dart

@@ -0,0 +1,39 @@
+import 'package:json_annotation/json_annotation.dart';
+
+import 'package:pshared/data/dto/date_time.dart';
+import 'package:pshared/data/dto/permissions/bound.dart';
+
+part 'recipient.g.dart';
+
+
+@JsonSerializable()
+class RecipientDTO extends PermissionBoundDTO {
+  final String name;
+  final String? description;
+  final String email;
+  final String? avatarUrl;
+  final String status;
+  final String type;
+
+  @JsonKey(defaultValue: false)
+  final bool isArchived;
+
+  const RecipientDTO({
+    required super.id,
+    required super.createdAt,
+    required super.updatedAt,
+    required super.permissionRef,
+    required super.organizationRef,
+    required this.name,
+    required this.email,
+    required this.status,
+    required this.type,
+    this.description,
+    this.avatarUrl,
+    this.isArchived = false,
+  });
+
+  factory RecipientDTO.fromJson(Map<String, dynamic> json) => _$RecipientDTOFromJson(json);
+  @override
+  Map<String, dynamic> toJson() => _$RecipientDTOToJson(this);
+}

frontend/pshared/lib/data/mapper/payment/card.dart

@@ -0,0 +1,19 @@
+import 'package:pshared/data/dto/payment/card.dart';
+import 'package:pshared/models/payment/methods/card.dart';
+
+
+extension CardPaymentMethodMapper on CardPaymentMethod {
+  CardPaymentDataDTO toDTO() => CardPaymentDataDTO(
+    pan: pan,
+    firstName: firstName,
+    lastName: lastName,
+  );
+}
+
+extension CardPaymentDataDTOMapper on CardPaymentDataDTO {
+  CardPaymentMethod toDomain() => CardPaymentMethod(
+    pan: pan,
+    firstName: firstName,
+    lastName: lastName,
+  );
+}