Merge pull request #91 from GMWalletApp/dev

Add Aptos USDT/USDC payment support and drive token RPC routing

.github/workflows/sync-www.yml

@@ -0,0 +1,101 @@
+name: sync-www
+
+on:
+  push:
+    branches:
+      - dev
+    paths-ignore:
+      - "src/www/**"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+concurrency:
+  group: sync-www-${{ github.ref_name }}
+  cancel-in-progress: false
+
+jobs:
+  build-and-sync:
+    name: Build Frontend And Sync src/www
+    runs-on: ubuntu-latest
+
+    env:
+      FRONTEND_REPOSITORY: ${{ vars.WWW_FRONTEND_REPOSITORY }}
+      FRONTEND_REF: ${{ vars.WWW_FRONTEND_REF }}
+      FRONTEND_BUILD_DIR: ${{ vars.WWW_FRONTEND_BUILD_DIR }}
+      FRONTEND_TOKEN: ${{ secrets.WWW_FRONTEND_TOKEN }}
+      WWW_TARGET_DIR: src/www
+
+    steps:
+      - name: Checkout Backend
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ github.ref_name }}
+          fetch-depth: 0
+
+      - name: Validate Configuration
+        run: |
+          if [[ -z "$FRONTEND_REPOSITORY" ]]; then
+            echo "Set repository variable WWW_FRONTEND_REPOSITORY, for example owner/repo"
+            exit 1
+          fi
+          if [[ -z "$FRONTEND_REF" ]]; then
+            echo "Set repository variable WWW_FRONTEND_REF, for example main"
+            exit 1
+          fi
+          if [[ -z "$FRONTEND_BUILD_DIR" ]]; then
+            echo "Set repository variable WWW_FRONTEND_BUILD_DIR, for example dist"
+            exit 1
+          fi
+          if [[ -z "$FRONTEND_TOKEN" ]]; then
+            echo "Set repository secret WWW_FRONTEND_TOKEN to read the private frontend repository"
+            exit 1
+          fi
+
+      - name: Clone Frontend
+        run: |
+          frontend_name="${FRONTEND_REPOSITORY##*/}"
+          frontend_path="$RUNNER_TEMP/$frontend_name"
+          git clone \
+            --depth=1 \
+            --branch "$FRONTEND_REF" \
+            "https://x-access-token:${FRONTEND_TOKEN}@github.com/${FRONTEND_REPOSITORY}.git" \
+            "$frontend_path"
+
+      - name: Set Up Bun
+        uses: oven-sh/setup-bun@v2
+
+      - name: Build Frontend
+        run: |
+          frontend_name="${FRONTEND_REPOSITORY##*/}"
+          cd "$RUNNER_TEMP/$frontend_name"
+          bun install
+          bun run build
+
+      - name: Replace src/www
+        run: |
+          frontend_name="${FRONTEND_REPOSITORY##*/}"
+          cd "$RUNNER_TEMP/$frontend_name"
+          if [[ ! -d "$FRONTEND_BUILD_DIR" ]]; then
+            echo "Frontend build output does not exist: $FRONTEND_BUILD_DIR"
+            exit 1
+          fi
+
+          target_path="$GITHUB_WORKSPACE/$WWW_TARGET_DIR"
+          mkdir -p "$target_path"
+          rsync -a --delete "$FRONTEND_BUILD_DIR"/ "$target_path"/
+
+      - name: Commit And Push
+        run: |
+          if [[ -z "$(git status --porcelain -- "$WWW_TARGET_DIR")" ]]; then
+            echo "src/www is already up to date"
+            exit 0
+          fi
+
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add "$WWW_TARGET_DIR"
+          git commit -m "chore(www): sync frontend build"
+          git pull --rebase origin "$GITHUB_REF_NAME"
+          git push origin "HEAD:$GITHUB_REF_NAME"

README.en.md

@@ -45,6 +45,7 @@ Deploy it privately, integrate with the HTTP API, and start receiving crypto pay
 | **Solana** | USDT, USDC |
 | **BEP20** (BSC) | USDT, USDC, BNB |
 | **Polygon** | USDT, USDC |
+| **Aptos** | USDC, USDT |
 | **More** | Expanding continuously |
 
 > Actual support depends on the [latest release](https://github.com/GMWalletApp/epusdt/releases) and the [official docs](https://epusdt.com).
@@ -68,7 +69,7 @@ No matter what kind of platform you operate, Epusdt can fit into existing paymen
 
 ## Core Features
 
-- **Multi-chain and multi-token** — TRC20, ERC20, BEP20, Polygon, and more
+- **Multi-chain and multi-token** — TRC20, ERC20, BEP20, Polygon, Aptos, and more
 - **Self-hosted** — full control of funds and wallet infrastructure
 - **Low-dependency runtime** — a single binary can run the service; low-traffic setups do not require MySQL + Redis
 - **Cross-platform** — supports x86 / ARM on Windows / Linux / Mac

README.md

@@ -45,6 +45,7 @@
 | **Solana** | USDT、USDC |
 | **BEP20** (BSC) | USDT、USDC、BNB |
 | **Polygon** | USDT、USDC |
+| **Aptos** | USDC、USDT |
 | **更多** | 持续扩展中… |
 
 > 具体支持的链与代币以 [最新版本](https://github.com/GMWalletApp/epusdt/releases) 及 [官方文档](https://epusdt.com) 为准。
@@ -74,7 +75,7 @@ Epusdt 已完成第三方安全审计。
 
 ## 核心特性
 
-- **多链多币种** — 支持 TRC20、ERC20、BEP20、Polygon 等主流网络
+- **多链多币种** — 支持 TRC20、ERC20、BEP20、Polygon、Aptos 等主流网络
 - **私有化部署** — 资金完全自主掌控
 - **零依赖运行** — 单个二进制即可启动，低并发场景无需 MySQL + Redis
 - **跨平台** — 支持 x86 / ARM 架构的 Windows / Linux / Mac

src/.gitignore

@@ -1,3 +1,4 @@
 .DS_Store
 dist/
 *.log
+bin/

src/Makefile

@@ -0,0 +1,41 @@
+APP := epusdt
+TARGET_DIR := bin
+BUILD_TAG ?= 0.0.0-dev
+VERSION_PKG := github.com/GMWalletApp/epusdt/config
+LDFLAGS := -s -w -X $(VERSION_PKG).BuildVersion=$(BUILD_TAG)
+
+.PHONY: build release build-all swagger \
+	linux-amd64 linux-arm64 linux-armv7 \
+	darwin-amd64 darwin-arm64 \
+	windows-amd64 windows-arm64
+
+build:
+	go build --trimpath -ldflags="$(LDFLAGS)" -o $(TARGET_DIR)/$(APP) .
+
+release: build
+
+linux-amd64:
+	GOOS=linux GOARCH=amd64 go build --trimpath -ldflags="$(LDFLAGS)" -o $(TARGET_DIR)/$(APP)-linux-amd64 .
+
+linux-arm64:
+	GOOS=linux GOARCH=arm64 go build --trimpath -ldflags="$(LDFLAGS)" -o $(TARGET_DIR)/$(APP)-linux-arm64 .
+
+linux-armv7:
+	GOOS=linux GOARCH=arm GOARM=7 go build --trimpath -ldflags="$(LDFLAGS)" -o $(TARGET_DIR)/$(APP)-linux-armv7 .
+
+darwin-amd64:
+	GOOS=darwin GOARCH=amd64 go build --trimpath -ldflags="$(LDFLAGS)" -o $(TARGET_DIR)/$(APP)-darwin-amd64 .
+
+darwin-arm64:
+	GOOS=darwin GOARCH=arm64 go build --trimpath -ldflags="$(LDFLAGS)" -o $(TARGET_DIR)/$(APP)-darwin-arm64 .
+
+windows-amd64:
+	GOOS=windows GOARCH=amd64 go build --trimpath -ldflags="$(LDFLAGS)" -o $(TARGET_DIR)/$(APP)-windows-amd64.exe .
+
+windows-arm64:
+	GOOS=windows GOARCH=arm64 go build --trimpath -ldflags="$(LDFLAGS)" -o $(TARGET_DIR)/$(APP)-windows-arm64.exe .
+
+build-all: linux-amd64 linux-arm64 linux-armv7 darwin-amd64 darwin-arm64 windows-amd64 windows-arm64
+
+swagger:
+	swag init --outputTypes json,yaml --parseInternal --parseDependency -o docs

src/bootstrap/bootstrap.go

@@ -6,6 +6,7 @@ import (
 	"github.com/GMWalletApp/epusdt/config"
 	"github.com/GMWalletApp/epusdt/model/dao"
 	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
 	"github.com/GMWalletApp/epusdt/mq"
 	"github.com/GMWalletApp/epusdt/task"
 	"github.com/GMWalletApp/epusdt/telegram"
@@ -21,6 +22,13 @@ func InitApp() {
 		config.Init()
 		log.Init()
 		dao.Init()
+		logLevel := data.GetSettingString(mdb.SettingKeySystemLogLevel, mdb.SettingDefaultSystemLogLevel)
+		if err := log.SetLevel(logLevel); err != nil {
+			color.Red.Printf("[bootstrap] apply log level setting %q err=%s; fallback=%s\n", logLevel, err, mdb.SettingDefaultSystemLogLevel)
+			if fallbackErr := log.SetLevel(mdb.SettingDefaultSystemLogLevel); fallbackErr != nil {
+				color.Red.Printf("[bootstrap] apply fallback log level err=%s\n", fallbackErr)
+			}
+		}
 		// Wire settings-table lookups into the config package so
 		// GetRateApiUrl / GetUsdtRate can consult admin-configured values.
 		config.SettingsGetString = func(key string) string {

src/config/config.go

@@ -352,7 +352,13 @@ func GetRateForCoin(coin string, base string) float64 {
 	if coin == "usdt" && base == "usd" {
 		return 1
 	}
-	return getRateForCoinFromAPI(coin, base)
+	if rate := getRateForCoinFromAPI(coin, base); rate > 0 {
+		return rate
+	}
+	if coin == "ton" {
+		return getRateForCoinFromAPI("toncoin", base)
+	}
+	return 0
 }
 
 func getForcedRateForCoin(coin string, base string) float64 {

src/config/config_test.go

@@ -329,6 +329,35 @@ func TestGetRateForCoinUsesAPIWhenForcedPairMissing(t *testing.T) {
 	}
 }
 
+func TestGetRateForCoinUsesToncoinAPIFallbackForTon(t *testing.T) {
+	viper.Reset()
+	t.Cleanup(viper.Reset)
+	t.Setenv("API_RATE_URL", "")
+
+	installMockHTTPClient(t, func(r *http.Request) (*http.Response, error) {
+		if r.URL.Path != "/cny.json" {
+			t.Fatalf("rate api path = %s, want /cny.json", r.URL.Path)
+		}
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Status:     "200 OK",
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(`{"cny":{"toncoin":1.82}}`)),
+			Request:    r,
+		}, nil
+	})
+
+	installSettingsGetter(t, map[string]string{
+		"rate.forced_rate_list": `{"cny":{"ton":0}}`,
+		"rate.api_url":          "https://rate.example.test",
+	})
+
+	rate := GetRateForCoin("ton", "cny")
+	if math.Abs(rate-1.82) > 1e-9 {
+		t.Fatalf("GetRateForCoin(ton, cny) = %v, want 1.82", rate)
+	}
+}
+
 func TestGetUsdtRateReturnsZeroWhenAPIUnavailableWithoutAdminOverride(t *testing.T) {
 	viper.Reset()
 	t.Cleanup(viper.Reset)

src/controller/admin/chain_controller.go

@@ -14,8 +14,7 @@ type UpdateChainRequest struct {
 	DisplayName      *string `json:"display_name" example:"Tron"`
 }
 
-// ListChains returns the chains table (tron/ethereum/solana seeded; new
+// ListChains returns the chains table for all seeded supported networks.
-// networks like bsc/polygon inserted manually once supported).
 // @Summary      List chains
 // @Description  Returns all supported blockchain networks
 // @Tags         Admin Chains
@@ -41,7 +40,7 @@ func (c *BaseAdminController) ListChains(ctx echo.Context) error {
 // @Security     AdminJWT
 // @Accept       json
 // @Produce      json
-// @Param        network path string true "Network name (e.g. tron, ethereum, solana)"
+// @Param        network path string true "Network name (e.g. ton, tron, ethereum, solana, aptos)"
 // @Param        request body admin.UpdateChainRequest true "Chain settings"
 // @Success      200 {object} response.ApiResponse
 // @Failure      400 {object} response.ApiResponse

src/controller/admin/chain_token_controller.go

@@ -14,6 +14,8 @@ import (
 type CreateChainTokenRequest struct {
 	Network string `json:"network" validate:"required" example:"tron"`
 	Symbol  string `json:"symbol" validate:"required|maxLen:32" example:"USDT"`
+	// Contract address or chain-native asset identifier. For Aptos this is
+	// the Move asset id (coin type, metadata address, or object type).
 	ContractAddress string  `json:"contract_address" example:"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"`
 	Decimals        int     `json:"decimals" example:"6"`
 	Enabled         *bool   `json:"enabled" example:"true"`
@@ -22,6 +24,8 @@ type CreateChainTokenRequest struct {
 
 // UpdateChainTokenRequest is the payload for updating a chain token.
 type UpdateChainTokenRequest struct {
+	// Contract address or chain-native asset identifier. For Aptos this is
+	// the Move asset id (coin type, metadata address, or object type).
 	ContractAddress *string  `json:"contract_address" example:"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"`
 	Decimals        *int     `json:"decimals" example:"6"`
 	Enabled         *bool    `json:"enabled" example:"true"`
@@ -33,6 +37,17 @@ type ChangeChainTokenStatusRequest struct {
 	Enabled bool `json:"enabled" example:"true"`
 }
 
+func validateChainTokenPaymentConfig(row *mdb.ChainToken) error {
+	if row == nil {
+		return nil
+	}
+	contractAddress := strings.TrimSpace(row.ContractAddress)
+	if row.Enabled && row.Network == mdb.NetworkAptos && contractAddress == "" {
+		return constant.ParamsMarshalErr
+	}
+	return nil
+}
+
 // ListChainTokens returns rows, optionally filtered by network.
 // @Summary      List chain tokens
 // @Description  Returns chain tokens, optionally filtered by network
@@ -54,7 +69,7 @@ func (c *BaseAdminController) ListChainTokens(ctx echo.Context) error {
 
 // CreateChainToken inserts a new row. Default decimals=6 when 0 passed.
 // @Summary      Create chain token
-// @Description  Create a new chain token entry
+// @Description  Create a new chain token entry. For Aptos, contract_address stores the Move asset id rather than an EVM contract address.
 // @Tags         Admin Chain Tokens
 // @Security     AdminJWT
 // @Accept       json
@@ -87,6 +102,9 @@ func (c *BaseAdminController) CreateChainToken(ctx echo.Context) error {
 		Enabled:         enabled,
 		MinAmount:       req.MinAmount,
 	}
+	if err := validateChainTokenPaymentConfig(row); err != nil {
+		return c.FailJson(ctx, err)
+	}
 	if err := data.CreateChainToken(row); err != nil {
 		return c.FailJson(ctx, err)
 	}
@@ -95,7 +113,7 @@ func (c *BaseAdminController) CreateChainToken(ctx echo.Context) error {
 
 // UpdateChainToken patches mutable columns.
 // @Summary      Update chain token
-// @Description  Patch chain token fields
+// @Description  Patch chain token fields. For Aptos, contract_address stores the Move asset id rather than an EVM contract address.
 // @Tags         Admin Chain Tokens
 // @Security     AdminJWT
 // @Accept       json
@@ -115,18 +133,35 @@ func (c *BaseAdminController) UpdateChainToken(ctx echo.Context) error {
 		return c.FailJson(ctx, constant.ParamsMarshalErr)
 	}
 	fields := map[string]interface{}{}
+	existing, err := data.GetChainTokenByID(id)
+	if err != nil {
+		return c.FailJson(ctx, err)
+	}
+	if existing == nil {
+		existing = &mdb.ChainToken{}
+	}
+	next := *existing
 	if req.ContractAddress != nil {
-		fields["contract_address"] = *req.ContractAddress
+		next.ContractAddress = strings.TrimSpace(*req.ContractAddress)
+		fields["contract_address"] = next.ContractAddress
 	}
 	if req.Decimals != nil {
+		next.Decimals = *req.Decimals
 		fields["decimals"] = *req.Decimals
 	}
 	if req.Enabled != nil {
+		next.Enabled = *req.Enabled
 		fields["enabled"] = *req.Enabled
 	}
 	if req.MinAmount != nil {
+		next.MinAmount = *req.MinAmount
 		fields["min_amount"] = *req.MinAmount
 	}
+	if next.ID > 0 {
+		if err = validateChainTokenPaymentConfig(&next); err != nil {
+			return c.FailJson(ctx, err)
+		}
+	}
 	if err := data.UpdateChainTokenFields(id, fields); err != nil {
 		return c.FailJson(ctx, err)
 	}
@@ -154,6 +189,17 @@ func (c *BaseAdminController) ChangeChainTokenStatus(ctx echo.Context) error {
 	if err := ctx.Bind(req); err != nil {
 		return c.FailJson(ctx, constant.ParamsMarshalErr)
 	}
+	row, err := data.GetChainTokenByID(id)
+	if err != nil {
+		return c.FailJson(ctx, err)
+	}
+	if row != nil && row.ID > 0 {
+		next := *row
+		next.Enabled = req.Enabled
+		if err = validateChainTokenPaymentConfig(&next); err != nil {
+			return c.FailJson(ctx, err)
+		}
+	}
 	if err := data.UpdateChainTokenFields(id, map[string]interface{}{"enabled": req.Enabled}); err != nil {
 		return c.FailJson(ctx, err)
 	}

src/controller/admin/chain_token_controller_test.go

@@ -0,0 +1,25 @@
+package admin
+
+import (
+	"testing"
+
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	"github.com/GMWalletApp/epusdt/util/constant"
+)
+
+func TestValidateChainTokenPaymentConfigRejectsEnabledAptosTokenWithoutAssetID(t *testing.T) {
+	for _, row := range []mdb.ChainToken{
+		{Network: mdb.NetworkAptos, Symbol: "USDT", Enabled: true},
+	} {
+		if err := validateChainTokenPaymentConfig(&row); err != constant.ParamsMarshalErr {
+			t.Fatalf("validateChainTokenPaymentConfig(%+v) = %v, want %v", row, err, constant.ParamsMarshalErr)
+		}
+	}
+}
+
+func TestValidateChainTokenPaymentConfigAllowsDisabledAptosTokenWithoutAssetID(t *testing.T) {
+	row := mdb.ChainToken{Network: mdb.NetworkAptos, Symbol: "USDT", Enabled: false}
+	if err := validateChainTokenPaymentConfig(&row); err != nil {
+		t.Fatalf("validateChainTokenPaymentConfig(%+v) = %v, want nil", row, err)
+	}
+}

src/controller/admin/order_controller.go

@@ -112,7 +112,7 @@ func (c *BaseAdminController) CloseOrder(ctx echo.Context) error {
 	if order.ID == 0 {
 		return c.FailJson(ctx, constant.OrderNotExists)
 	}
-	if order.Status != mdb.StatusWaitPay {
+	if order.Status != mdb.StatusWaitPay && order.Status != mdb.StatusWaitSelect {
 		return c.FailJson(ctx, constant.OrderNotWaitPay)
 	}
 	ok, err := data.CloseOrderManually(tradeID)
@@ -122,8 +122,16 @@ func (c *BaseAdminController) CloseOrder(ctx echo.Context) error {
 	if !ok {
 		return c.FailJson(ctx, constant.OrderStatusConflict)
 	}
-	// Release the transaction lock so the amount slot becomes reusable.
+	// Release only concrete on-chain locks. Placeholder orders and provider-only
+	// orders do not reserve a local wallet amount.
+	if order.Status == mdb.StatusWaitPay &&
+		(strings.TrimSpace(order.PayProvider) == "" || order.PayProvider == mdb.PaymentProviderOnChain) &&
+		strings.TrimSpace(order.Network) != "" &&
+		strings.TrimSpace(order.ReceiveAddress) != "" &&
+		strings.TrimSpace(order.Token) != "" &&
+		order.ActualAmount > 0 {
 		_ = data.UnLockTransaction(order.Network, order.ReceiveAddress, order.Token, order.ActualAmount)
+	}
 	return c.SucJson(ctx, nil)
 }
 
@@ -132,6 +140,9 @@ func (c *BaseAdminController) CloseOrder(ctx echo.Context) error {
 // callback + notification fire normally.
 // @Summary      Mark order paid
 // @Description  Manually mark a waiting order as paid (operator补单)
+// @Description  TON accepts canonical ton:<receive_raw>:<lt>:<hash>, lt:hash, or a unique recent hash-only reference for the order receive address.
+// @Description  Aptos accepts a transaction hash.
+// @Description  Aptos automatic scanning polls fullnode ledger-version transaction ranges with a runtime cursor.
 // @Tags         Admin Orders
 // @Security     AdminJWT
 // @Accept       json

src/controller/admin/rpc_controller.go

@@ -16,8 +16,8 @@ import (
 type CreateRpcNodeRequest struct {
 	Network string `json:"network" validate:"required" example:"tron"`
 	Url     string `json:"url" validate:"required" example:"https://api.trongrid.io"`
-	// 连接类型 http=HTTP请求 ws=WebSocket长连接
+	// 连接类型 http=HTTP请求 ws=WebSocket长连接 lite=TON liteserver配置
-	Type    string `json:"type" validate:"required|in:http,ws" enums:"http,ws" example:"http"`
+	Type    string `json:"type" validate:"required|in:http,ws,lite" enums:"http,ws,lite" example:"http"`
 	Weight  int    `json:"weight" example:"1"`
 	ApiKey  string `json:"api_key" example:""`
 	Enabled *bool  `json:"enabled" example:"true"`
@@ -187,9 +187,8 @@ func (c *BaseAdminController) DeleteRpcNode(ctx echo.Context) error {
 }
 
 // HealthCheckRpcNode performs an on-demand probe and writes the result.
-// For HTTP endpoints this is a GET to the URL with a short timeout; for
+// For HTTP/WS/lite endpoints this is a TCP-level check against the configured
-// WS we just attempt a TCP-level check via the same HTTP client (the
+// URL host. TON lite rows usually point to a global.config.json HTTPS URL.
-// handshake URL resolves the host identically).
 // @Summary      Health check RPC node
 // @Description  Perform an on-demand health probe on an RPC node
 // @Tags         Admin RPC Nodes
@@ -253,6 +252,11 @@ func validateRpcNodeURLForType(rawURL string, nodeType string) error {
 			return nil
 		}
 		return constant.RpcNodeWebSocketURLErr
+	case mdb.RpcNodeTypeLite:
+		if scheme == "http" || scheme == "https" {
+			return nil
+		}
+		return constant.RpcNodeHTTPURLErr
 	default:
 		return constant.RpcNodeTypeErr
 	}

src/controller/admin/settings_controller.go

@@ -11,6 +11,7 @@ import (
 	"github.com/GMWalletApp/epusdt/model/mdb"
 	"github.com/GMWalletApp/epusdt/telegram"
 	"github.com/GMWalletApp/epusdt/util/constant"
+	appLog "github.com/GMWalletApp/epusdt/util/log"
 	"github.com/GMWalletApp/epusdt/util/security"
 	"github.com/labstack/echo/v4"
 )
@@ -19,15 +20,15 @@ import (
 // Supported groups and keys:
 //
 //   - group=rate:
-//     rate.forced_rate_list  (json)   — override rate map, e.g. {"cny":{"usdt":0.14635}}; base/coin keys are normalized to lowercase
+//     rate.forced_rate_list  (json)   — override rate map, e.g. {"cny":{"usdt":0.14635,"ton":0.5}}; base/coin keys are normalized to lowercase
 //     rate.api_url           (string) — external rate API URL used when no positive forced rate exists
 //     rate.adjust_percent    (float)  — rate adjustment percentage
 //     rate.okx_c2c_enabled   (bool)   — use OKX C2C rate feed
 //
 //   - group=epay:
-//     epay.default_token     (string) — token for EPAY orders, e.g. "usdt" (default)
+//     epay.default_token     (string) — default token for EPAY submit.php, e.g. "usdt"; empty allows status=4 placeholders when request token/network are also absent
-//     epay.default_currency  (string) — fiat currency for EPAY orders, e.g. "cny" (default)
+//     epay.default_currency  (string) — default fiat currency for EPAY submit.php, e.g. "cny"; empty falls back to cny
-//     epay.default_network   (string) — blockchain network for EPAY orders, e.g. "tron" (default)
+//     epay.default_network   (string) — default network for EPAY submit.php, e.g. "tron" or "ton"; empty allows status=4 placeholders when request token/network are also absent
 //
 //   - group=okpay:
 //     okpay.enabled          (bool)   — enable OkPay as a switch-network payment option
@@ -54,6 +55,7 @@ import (
 //   - group=system:
 //     system.order_expiration_time (int) — order expiry in minutes
 //     system.amount_precision      (int) — payment amount precision, 2-6 decimals (default 2)
+//     system.log_level             (string) — runtime log level: debug, info, warn, error (default error)
 type SettingUpsertItem struct {
 	Group string      `json:"group" enums:"brand,rate,system,epay,okpay" example:"epay"`
 	Key   string      `json:"key" example:"epay.default_network"`
@@ -93,11 +95,11 @@ func (c *BaseAdminController) ListSettings(ctx echo.Context) error {
 // @Summary      Upsert settings
 // @Description  Batch insert/update settings. Returns per-key status; failed items include error_code for frontend i18n.
 // @Description  Supported groups: brand, rate, system, epay, okpay.
-// @Description  epay group keys: epay.default_token (e.g. "usdt"), epay.default_currency (e.g. "cny"), epay.default_network (e.g. "tron").
+// @Description  epay group keys: epay.default_token (e.g. "usdt" or "ton", empty allows status=4 placeholders), epay.default_currency (e.g. "cny", empty falls back to cny), epay.default_network (e.g. "tron" or "ton", empty allows status=4 placeholders).
 // @Description  okpay group keys: okpay.enabled, okpay.shop_id, okpay.shop_token, okpay.api_url, okpay.callback_url, okpay.return_url, okpay.timeout_seconds, okpay.allow_tokens.
-// @Description  rate group keys: rate.forced_rate_list (JSON map, e.g. {"cny":{"usdt":0.14635}}; base/coin keys are normalized to lowercase), rate.api_url, rate.adjust_percent, rate.okx_c2c_enabled.
+// @Description  rate group keys: rate.forced_rate_list (JSON map, e.g. {"cny":{"usdt":0.14635,"ton":0.5}}; base/coin keys are normalized to lowercase), rate.api_url, rate.adjust_percent, rate.okx_c2c_enabled.
 // @Description  brand group keys: brand.checkout_name, brand.logo_url, brand.site_title, brand.success_copy, brand.support_url, brand.background_color, brand.background_image_url. Legacy aliases brand.site_name, brand.page_title and brand.pay_success_text are also supported.
-// @Description  system group keys: system.order_expiration_time, system.amount_precision (int, 2-6, default 2).
+// @Description  system group keys: system.order_expiration_time, system.amount_precision (int, 2-6, default 2), system.log_level (debug|info|warn|error, default error).
 // @Tags         Admin Settings
 // @Security     AdminJWT
 // @Accept       json
@@ -149,10 +151,20 @@ func (c *BaseAdminController) UpsertSettings(ctx echo.Context) error {
 			item.Group = mdb.SettingGroupRate
 			item.Type = mdb.SettingTypeJSON
 		}
+		if key == mdb.SettingKeySystemLogLevel {
+			item.Group = mdb.SettingGroupSystem
+			item.Type = mdb.SettingTypeString
+		}
 		if err := data.SetSetting(item.Group, key, value, item.Type); err != nil {
 			out = append(out, errorResult(key, err))
 			continue
 		}
+		if key == mdb.SettingKeySystemLogLevel {
+			if err := appLog.SetLevel(value); err != nil {
+				out = append(out, errorResult(key, err))
+				continue
+			}
+		}
 		out = append(out, result{Key: key, OK: true})
 	}
 
@@ -218,6 +230,15 @@ func normalizeAndValidateSettingItem(group, key, value string) (string, error) {
 		if err := security.ValidatePublicHTTPURL(value); err != nil {
 			return value, fmt.Errorf("%s invalid: %w", key, err)
 		}
+	case mdb.SettingKeySystemLogLevel:
+		if strings.ToLower(strings.TrimSpace(group)) != mdb.SettingGroupSystem {
+			return value, fmt.Errorf("%s must use group %s", key, mdb.SettingGroupSystem)
+		}
+		normalized, err := appLog.NormalizeLevel(value)
+		if err != nil {
+			return value, err
+		}
+		return normalized, nil
 	}
 	return value, nil
 }
@@ -274,7 +295,7 @@ func normalizeForcedRateListSetting(group, key, value string) (string, error) {
 // DeleteSetting removes one row. The next read of that key will fall
 // back to the hardcoded default (see settings_data.GetSetting*).
 // @Summary      Delete setting
-// @Description  Remove a setting by key (falls back to default)
+// @Description  Remove a setting by key (falls back to default). Deleting system.log_level immediately resets runtime logging to error.
 // @Tags         Admin Settings
 // @Security     AdminJWT
 // @Produce      json
@@ -290,5 +311,10 @@ func (c *BaseAdminController) DeleteSetting(ctx echo.Context) error {
 	if err := data.DeleteSetting(key); err != nil {
 		return c.FailJson(ctx, err)
 	}
+	if key == mdb.SettingKeySystemLogLevel {
+		if err := appLog.SetLevel(mdb.SettingDefaultSystemLogLevel); err != nil {
+			return c.FailJson(ctx, err)
+		}
+	}
 	return c.SucJson(ctx, nil)
 }

src/controller/comm/order_controller.go

@@ -25,6 +25,8 @@ func apiKeyFromContext(ctx echo.Context) *mdb.ApiKey {
 // CreateTransaction 创建交易
 // @Summary      Create transaction
 // @Description  Create a payment transaction order. Accepts JSON body (application/json) or form-encoded body (application/x-www-form-urlencoded).
+// @Description  GMPay may omit both token and network to create a status=4 placeholder order; EPay submit.php can also create one when neither request parameters nor database defaults provide token/network. Supplying only one of token/network is invalid.
+// @Description  payment_type is optional for GMPay. If it is sent, it is a normal signed parameter and must be included when calculating signature.
 // @Tags         Payment
 // @Accept       json
 // @Accept       x-www-form-urlencoded
@@ -32,16 +34,16 @@ func apiKeyFromContext(ctx echo.Context) *mdb.ApiKey {
 // @Param        request body request.CreateTransactionRequest false "Transaction payload (JSON)"
 // @Param        order_id formData string false "Merchant order ID"
 // @Param        currency formData string false "Fiat currency (e.g. cny)"
-// @Param        token formData string false "Crypto token (e.g. usdt)"
+// @Param        token formData string false "Crypto token (e.g. TON, USDT); omit together with network to create a placeholder where supported"
-// @Param        network formData string false "Network (e.g. tron)"
+// @Param        network formData string false "Network (e.g. ton, tron); omit together with token to create a placeholder where supported"
 // @Param        amount formData number false "Amount"
 // @Param        notify_url formData string false "Callback URL"
 // @Param        signature formData string false "MD5 signature"
 // @Param        redirect_url formData string false "Redirect URL"
 // @Param        name formData string false "Order name"
-// @Param        payment_type formData string false "Payment type"
+// @Param        payment_type formData string false "Optional GMPay compatibility flag; include in signature when sent"
 // @Success      200 {object} response.ApiResponse{data=response.CreateTransactionResponse}
-// @Failure      400 {object} response.ApiResponse "Stable errno in status_code: 10009 invalid params, 10041 invalid notify_url, 10004 invalid amount, 10014 chain disabled, 10003 no wallet, 10005 no amount channel"
+// @Failure      400 {object} response.ApiResponse "Stable errno in status_code: 10009 invalid params, 10041 invalid notify_url, 10004 invalid amount, 10014 chain disabled, 10016 unsupported asset, 10003 no wallet, 10005 no amount channel"
 // @Router       /payments/gmpay/v1/order/create-transaction [post]
 func (c *BaseCommController) CreateTransaction(ctx echo.Context) (err error) {
 	req := new(request.CreateTransactionRequest)
@@ -58,17 +60,18 @@ func (c *BaseCommController) CreateTransaction(ctx echo.Context) (err error) {
 	return c.SucJson(ctx, resp)
 }
 
-// SwitchNetwork 切换支付网络，创建或返回子订单
+// SwitchNetwork 切换支付网络，补全占位父单或创建/返回子订单
 // @Summary      Switch payment network
-// @Description  Switch to a different payment target, creating or returning a sub-order.
+// @Description  Switch to a different payment target. A status=4 placeholder is completed in place and returns the same parent trade_id with is_selected=false; an already concrete status=1 parent creates or returns the only sub-order when switching to a different target.
-// @Description  Normal values such as tron/solana/ethereum create on-chain child orders.
+// @Description  Normal values such as ton/tron/solana/ethereum select on-chain payment; the special value okpay selects OkPay hosted payment.
-// @Description  The special value okpay creates or reuses an OkPay-hosted child order and returns its payment_url.
+// @Description  For status=4 placeholders from GMPay or EPay submit.php, both on-chain targets and okpay complete the parent in place without creating a child order. Sub-orders cannot be switched again.
+// @Description  For EPay orders with a merchant return_url, the returned redirect_url is the internal /pay/return/{trade_id} hop rather than the raw merchant return_url.
 // @Tags         Payment
 // @Accept       json
 // @Produce      json
 // @Param        request body request.SwitchNetworkRequest true "Switch network payload"
 // @Success      200 {object} response.ApiResponse{data=response.CheckoutCounterResponse}
-// @Failure      400 {object} response.ApiResponse "Stable errno in status_code: 10008 order not found, 10012 cannot switch sub-order, 10013 not waiting payment, 10017/10018/10019 provider errors, 10042 provider order creation failed"
+// @Failure      400 {object} response.ApiResponse "Stable errno in status_code: 10008 order not found, 10011 sub-order limit, 10012 cannot switch sub-order, 10013 not waiting payment, 10016 unsupported asset, 10017/10018/10019 provider errors, 10042 provider order creation failed"
 // @Router       /pay/switch-network [post]
 func (c *BaseCommController) SwitchNetwork(ctx echo.Context) (err error) {
 	req := new(request.SwitchNetworkRequest)
@@ -98,7 +101,7 @@ func (c *BaseCommController) SwitchNetwork(ctx echo.Context) (err error) {
 // POST (form) per the legacy EPAY protocol; swagger documents POST as
 // the canonical form — the GET variant is identical save the transport.
 // @Summary      Create transaction and redirect (EPAY compat)
-// @Description  Legacy EPAY-style endpoint. Accepts GET (querystring) and POST (form). On success, 302 redirects to /pay/checkout-counter/{trade_id}. Signature uses MD5 of sorted params + secret_key of the api_keys row matching the submitted pid.
+// @Description  Legacy EPAY-style endpoint. Accepts GET (querystring) and POST (form). On success, 302 redirects to /pay/checkout-counter/{trade_id}. Signature uses MD5 of sorted params + secret_key of the api_keys row matching the submitted pid. Optional request token/network/currency override database defaults and must be included in the EPay signature when sent. The server injects internal payment_type=Epay after EPay signature verification; merchants do not send GMPay payment_type to this endpoint.
 // @Tags         Payment
 // @Accept       x-www-form-urlencoded
 // @Produce      html
@@ -121,7 +124,7 @@ func (c *BaseCommController) SwitchNetwork(ctx echo.Context) (err error) {
 // @Param        sign formData string true "MD5 signature"
 // @Param        sign_type formData string false "Signature type (MD5)"
 // @Success      302 "Redirect to checkout counter"
-// @Failure      400 {object} response.ApiResponse "Stable errno in status_code: 10009 invalid params, 10041 invalid notify_url, 10004 invalid amount, 10014 chain disabled, 10003 no wallet, 10005 no amount channel"
+// @Failure      400 {object} response.ApiResponse "Stable errno in status_code: 10009 invalid params, 10041 invalid notify_url, 10004 invalid amount, 10014 chain disabled, 10016 unsupported asset, 10003 no wallet, 10005 no amount channel"
 // @Router       /payments/epay/v1/order/create-transaction/submit.php [post]
 // @Router       /payments/epay/v1/order/create-transaction/submit.php [get]
 func (c *BaseCommController) CreateTransactionAndRedirect(ctx echo.Context) (err error) {

src/controller/comm/pay_controller.go

@@ -1,6 +1,7 @@
 package comm
 
 import (
+	"net/http"
 	"strings"
 
 	"github.com/GMWalletApp/epusdt/model/request"
@@ -12,7 +13,9 @@ import (
 
 // CheckoutCounter 收银台
 // @Summary      Checkout counter page
-// @Description  Return checkout initialization data when the order exists. This endpoint only confirms order existence and returns base order data; call /pay/check-status/{trade_id} for the current order status (1=waiting payment, 2=paid, 3=expired).
+// @Description  Return checkout initialization data when the order exists. This endpoint only confirms order existence and returns base order data; call /pay/check-status/{trade_id} for the current order status (1=waiting payment, 2=paid, 3=expired, 4=waiting token/network selection).
+// @Description  When status=4, actual_amount is 0 and token/network/receive_address are empty; this state is produced by GMPay placeholders or EPay submit.php when no token/network request values or database defaults exist. The cashier should guide the payer to choose an on-chain token/network or OkPay and then call /pay/switch-network.
+// @Description  For EPay orders with a merchant return_url, the response redirect_url is rewritten to the internal /pay/return/{trade_id} hop; the database still stores the merchant's raw return_url.
 // @Tags         Payment
 // @Produce      json
 // @Param        trade_id path string true "Trade ID"
@@ -29,9 +32,32 @@ func (c *BaseCommController) CheckoutCounter(ctx echo.Context) (err error) {
 	return c.SucJson(ctx, resp)
 }
 
+// ReturnToMerchant performs the browser-facing EPay success return hop.
+// Non-EPay or not-yet-paid orders are sent back to the checkout counter.
+// @Summary      Return to merchant (EPAY compat)
+// @Description  Browser-facing success return hop for EPay orders. Paid EPay orders are redirected to the merchant return_url with signed legacy EPay query params. Orders that are not EPay or not yet paid are redirected back to the checkout counter.
+// @Description  This route also returns explicit business errors when the merchant return_url is missing, the order API key is unavailable, or EPay signature construction fails.
+// @Tags         Payment
+// @Produce      html
+// @Param        trade_id path string true "Trade ID"
+// @Success      302 "Redirect to merchant return_url or checkout counter"
+// @Failure      400 {object} response.ApiResponse "Stable errno in status_code: 10008 order not found, 10044 invalid order redirect url, 10045 order api key unavailable, 10046 failed to build epay return signature"
+// @Router       /pay/return/{trade_id} [get]
+func (c *BaseCommController) ReturnToMerchant(ctx echo.Context) error {
+	tradeID := ctx.Param("trade_id")
+	redirect, err := service.ResolveEPayReturnRedirect(tradeID)
+	if err != nil {
+		return c.FailJson(ctx, err)
+	}
+	if redirect.IsMerchantRedirect {
+		ctx.Response().Header().Set("Cache-Control", "no-store")
+	}
+	return ctx.Redirect(http.StatusFound, redirect.TargetURL)
+}
+
 // CheckStatus 支付状态检测
 // @Summary      Check payment status
-// @Description  Return the current order status by trade ID. Status: 1=waiting payment, 2=paid, 3=expired.
+// @Description  Return the current order status by trade ID. Status: 1=waiting payment, 2=paid, 3=expired, 4=waiting token/network selection.
 // @Tags         Payment
 // @Produce      json
 // @Param        trade_id path string true "Trade ID"
@@ -54,6 +80,9 @@ func (c *BaseCommController) CheckStatus(ctx echo.Context) (err error) {
 // SubmitTxHash 手动提交交易 hash 补单
 // @Summary      Submit transaction hash
 // @Description  Submit an on-chain transaction hash from the cashier. The hash is verified against the order and, when valid, the same manual payment processing path used by admin mark-paid is executed. OkPay/provider orders are not supported.
+// @Description  TON accepts canonical ton:<receive_raw>:<lt>:<hash>, lt:hash, or a unique recent hash-only reference for the order receive address.
+// @Description  Aptos accepts a transaction hash.
+// @Description  Aptos automatic scanning polls fullnode ledger-version transaction ranges with a runtime cursor.
 // @Tags         Payment
 // @Accept       json
 // @Produce      json

src/controller/comm/supported_asset_controller.go

@@ -10,6 +10,7 @@ import (
 	"github.com/GMWalletApp/epusdt/model/data"
 	"github.com/GMWalletApp/epusdt/model/mdb"
 	"github.com/GMWalletApp/epusdt/model/response"
+	"github.com/GMWalletApp/epusdt/model/service"
 	"github.com/GMWalletApp/epusdt/util/constant"
 	"github.com/labstack/echo/v4"
 )
@@ -44,6 +45,9 @@ func buildSupportedAssets() ([]response.NetworkTokenSupport, error) {
 		}
 		symbols := make([]string, 0, len(tokens))
 		for _, t := range tokens {
+			if !service.ChainTokenReadyForPayment(t) {
+				continue
+			}
 			sym := strings.ToUpper(strings.TrimSpace(t.Symbol))
 			if sym == "" {
 				continue
@@ -109,9 +113,9 @@ func (c *BaseCommController) GetPublicConfig(ctx echo.Context) error {
 			BackgroundImageURL: data.GetBrandBackgroundImageURL(),
 		},
 		Epay: response.EpayPublicConfig{
-			DefaultToken:    data.GetSettingString(mdb.SettingKeyEpayDefaultToken, "usdt"),
+			DefaultToken:    data.GetSettingString(mdb.SettingKeyEpayDefaultToken, ""),
 			DefaultCurrency: data.GetSettingString(mdb.SettingKeyEpayDefaultCurrency, "cny"),
-			DefaultNetwork:  data.GetSettingString(mdb.SettingKeyEpayDefaultNetwork, "tron"),
+			DefaultNetwork:  data.GetSettingString(mdb.SettingKeyEpayDefaultNetwork, ""),
 		},
 		OkPay:   okpay,
 		Version: config.GetAppVersion(),

src/controller/comm/supported_asset_controller_test.go

@@ -0,0 +1,51 @@
+package comm
+
+import (
+	"testing"
+
+	"github.com/GMWalletApp/epusdt/internal/testutil"
+	"github.com/GMWalletApp/epusdt/model/dao"
+	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
+)
+
+func TestBuildSupportedAssetsIncludesConfiguredAptosTokens(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := dao.Mdb.Create(&mdb.Chain{Network: mdb.NetworkAptos, Enabled: true, DisplayName: "Aptos"}).Error; err != nil {
+		t.Fatalf("create aptos chain: %v", err)
+	}
+	if _, err := data.AddWalletAddressWithNetwork(mdb.NetworkAptos, "0x1"); err != nil {
+		t.Fatalf("add aptos wallet: %v", err)
+	}
+	for _, row := range []mdb.ChainToken{
+		{Network: mdb.NetworkAptos, Symbol: "USDT", ContractAddress: "0x357b0b74bc833e95a115ad22604854d6b0fca151cecd94111770e5d6ffc9dc2b", Decimals: 6, Enabled: true},
+		{Network: mdb.NetworkAptos, Symbol: "MOVEUSD", ContractAddress: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Decimals: 6, Enabled: true},
+		{Network: mdb.NetworkAptos, Symbol: "USDC", ContractAddress: "", Decimals: 6, Enabled: true},
+	} {
+		if err := dao.Mdb.Create(&row).Error; err != nil {
+			t.Fatalf("create token %s: %v", row.Symbol, err)
+		}
+	}
+
+	supports, err := buildSupportedAssets()
+	if err != nil {
+		t.Fatalf("buildSupportedAssets: %v", err)
+	}
+	if len(supports) != 1 {
+		t.Fatalf("supported assets len = %d, want 1: %#v", len(supports), supports)
+	}
+	if supports[0].Network != mdb.NetworkAptos {
+		t.Fatalf("network = %q, want %q", supports[0].Network, mdb.NetworkAptos)
+	}
+	want := []string{"MOVEUSD", "USDT"}
+	if len(supports[0].Tokens) != len(want) {
+		t.Fatalf("tokens = %#v, want %#v", supports[0].Tokens, want)
+	}
+	for i := range want {
+		if supports[0].Tokens[i] != want[i] {
+			t.Fatalf("tokens = %#v, want %#v", supports[0].Tokens, want)
+		}
+	}
+}

src/go.mod

@@ -23,6 +23,7 @@ require (
 	github.com/spf13/cobra v1.9.1
 	github.com/spf13/viper v1.20.1
 	github.com/tidwall/gjson v1.18.0
+	github.com/xssnick/tonutils-go v1.16.0
 	go.uber.org/zap v1.27.0
 	golang.org/x/crypto v0.48.0
 	gopkg.in/telebot.v3 v3.0.0

src/go.sum

@@ -348,6 +348,8 @@ github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778 h1:QldyIu/L63oPpyvQmHg
 github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778/go.mod h1:2MuV+tbUrU1zIOPMxZ5EncGwgmMJsa+9ucAQZXxsObs=
 github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4=
 github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=
+github.com/xssnick/tonutils-go v1.16.0 h1:MLYVZiiMB0Q+XudLo7WyjOli4gMuenNmJpBqETqa5DE=
+github.com/xssnick/tonutils-go v1.16.0/go.mod h1:CNSM+L0FYufOFhprg8otc9Y/ecFfLrWqFMq00Gh9yk4=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 go.mongodb.org/mongo-driver v1.17.3 h1:TQyXhnsWfWtgAhMtOgtYHMTkZIfBTpMTsMnd9ZBeHxQ=

src/internal/testutil/testdb.go

@@ -12,6 +12,7 @@ import (
 	"github.com/spf13/viper"
 	"go.uber.org/zap"
 	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
 	"gorm.io/gorm/logger"
 	"gorm.io/gorm/schema"
 )
@@ -65,11 +66,19 @@ func SetupTestDatabases(t testing.TB) func() {
 	// Seed all standard chains as enabled so IsChainEnabled checks pass.
 	for _, network := range []string{
 		mdb.NetworkTron, mdb.NetworkSolana, mdb.NetworkEthereum,
-		mdb.NetworkBsc, mdb.NetworkPolygon, mdb.NetworkPlasma,
+		mdb.NetworkBsc, mdb.NetworkPolygon, mdb.NetworkPlasma, mdb.NetworkTon,
 	} {
 		mainDB.Create(&mdb.Chain{Network: network, Enabled: true})
 	}
 
+	mainDB.Clauses(clause.OnConflict{DoNothing: true}).Create(&[]mdb.ChainToken{
+		{Network: mdb.NetworkTron, Symbol: "USDT", ContractAddress: "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", Decimals: 6, Enabled: true},
+		{Network: mdb.NetworkEthereum, Symbol: "USDT", ContractAddress: "0xdAC17F958D2ee523a2206206994597C13D831ec7", Decimals: 6, Enabled: true},
+		{Network: mdb.NetworkBsc, Symbol: "USDT", ContractAddress: "0x55d398326f99059fF775485246999027B3197955", Decimals: 18, Enabled: true},
+		{Network: mdb.NetworkTon, Symbol: "TON", ContractAddress: "", Decimals: 9, Enabled: true},
+		{Network: mdb.NetworkTon, Symbol: "USDT", ContractAddress: "0:b113a994b5024a16719f69139328eb759596c38a25f59028b146fecdc3621dfe", Decimals: 6, Enabled: true},
+	})
+
 	// Seed two universal api_keys rows. Both usable for EPAY/GMPAY
 	// flows; the numeric PID 1001 row lets legacy tests that submit
 	// `pid=1001` still match.

src/model/dao/mdb_table_init.go

@@ -64,6 +64,8 @@ func seedChains() {
 		{Network: mdb.NetworkBsc, DisplayName: "BSC", Enabled: true, MinConfirmations: 3, ScanIntervalSec: 5},
 		{Network: mdb.NetworkPolygon, DisplayName: "Polygon", Enabled: true, MinConfirmations: 3, ScanIntervalSec: 5},
 		{Network: mdb.NetworkPlasma, DisplayName: "Plasma", Enabled: true, MinConfirmations: 1, ScanIntervalSec: 5},
+		{Network: mdb.NetworkTon, DisplayName: "TON", Enabled: true, MinConfirmations: 1, ScanIntervalSec: 5},
+		{Network: mdb.NetworkAptos, DisplayName: "Aptos", Enabled: true, MinConfirmations: 1, ScanIntervalSec: 5},
 	}
 	if err := Mdb.Clauses(clause.OnConflict{DoNothing: true}).Create(&defaults).Error; err != nil {
 		color.Red.Printf("[store_db] seed chains err=%s\n", err)
@@ -98,6 +100,11 @@ func seedChainTokens() {
 		{Network: mdb.NetworkPolygon, Symbol: "USDC.e", ContractAddress: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174", Decimals: 6, Enabled: true},
 		// Plasma
 		{Network: mdb.NetworkPlasma, Symbol: "USDT", ContractAddress: "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb", Decimals: 6, Enabled: true},
+		// TON
+		{Network: mdb.NetworkTon, Symbol: "TON", ContractAddress: "", Decimals: 9, Enabled: true},
+		{Network: mdb.NetworkTon, Symbol: "USDT", ContractAddress: "0:b113a994b5024a16719f69139328eb759596c38a25f59028b146fecdc3621dfe", Decimals: 6, Enabled: true},
+		{Network: mdb.NetworkAptos, Symbol: "USDC", ContractAddress: "0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b", Decimals: 6, Enabled: true},
+		{Network: mdb.NetworkAptos, Symbol: "USDT", ContractAddress: "0x357b0b74bc833e95a115ad22604854d6b0fca151cecd94111770e5d6ffc9dc2b", Decimals: 6, Enabled: true},
 	}
 	if err := Mdb.Clauses(clause.OnConflict{DoNothing: true}).Create(&defaults).Error; err != nil {
 		color.Red.Printf("[store_db] seed chain_tokens err=%s\n", err)
@@ -133,6 +140,8 @@ func defaultRpcNodes() []mdb.RpcNode {
 		{Network: mdb.NetworkBsc, Url: "wss://bsc.drpc.org", Type: mdb.RpcNodeTypeWs, Weight: 1, Enabled: true, Purpose: mdb.RpcNodePurposeGeneral, Status: mdb.RpcNodeStatusUnknown},
 		{Network: mdb.NetworkPolygon, Url: "wss://polygon-bor-rpc.publicnode.com", Type: mdb.RpcNodeTypeWs, Weight: 1, Enabled: true, Purpose: mdb.RpcNodePurposeGeneral, Status: mdb.RpcNodeStatusUnknown},
 		{Network: mdb.NetworkPlasma, Url: "wss://rpc.plasma.to", Type: mdb.RpcNodeTypeWs, Weight: 1, Enabled: true, Purpose: mdb.RpcNodePurposeGeneral, Status: mdb.RpcNodeStatusUnknown},
+		{Network: mdb.NetworkTon, Url: "https://ton-blockchain.github.io/global.config.json", Type: mdb.RpcNodeTypeLite, Weight: 1, Enabled: true, Purpose: mdb.RpcNodePurposeGeneral, Status: mdb.RpcNodeStatusUnknown},
+		{Network: mdb.NetworkAptos, Url: "https://aptos-rest.publicnode.com/", Type: mdb.RpcNodeTypeHttp, Weight: 1, Enabled: true, Purpose: mdb.RpcNodePurposeGeneral, Status: mdb.RpcNodeStatusUnknown},
 		{Network: mdb.NetworkEthereum, Url: "https://rpc.epusdt.com/ethereum", Type: mdb.RpcNodeTypeHttp, Weight: 1, Enabled: true, Purpose: mdb.RpcNodePurposeManualVerify, Status: mdb.RpcNodeStatusUnknown},
 		{Network: mdb.NetworkBsc, Url: "https://rpc.epusdt.com/binance", Type: mdb.RpcNodeTypeHttp, Weight: 1, Enabled: true, Purpose: mdb.RpcNodePurposeManualVerify, Status: mdb.RpcNodeStatusUnknown},
 		{Network: mdb.NetworkPolygon, Url: "https://rpc.epusdt.com/polygon", Type: mdb.RpcNodeTypeHttp, Weight: 1, Enabled: true, Purpose: mdb.RpcNodePurposeManualVerify, Status: mdb.RpcNodeStatusUnknown},
@@ -157,9 +166,10 @@ func seedDefaultSettings() {
 	}
 	defaults := []mdb.Setting{
 		{Group: mdb.SettingGroupSystem, Key: mdb.SettingKeyAmountPrecision, Value: "2", Type: mdb.SettingTypeInt},
-		{Group: mdb.SettingGroupEpay, Key: mdb.SettingKeyEpayDefaultToken, Value: "usdt", Type: mdb.SettingTypeString},
+		{Group: mdb.SettingGroupSystem, Key: mdb.SettingKeySystemLogLevel, Value: mdb.SettingDefaultSystemLogLevel, Type: mdb.SettingTypeString},
+		{Group: mdb.SettingGroupEpay, Key: mdb.SettingKeyEpayDefaultToken, Value: "", Type: mdb.SettingTypeString},
 		{Group: mdb.SettingGroupEpay, Key: mdb.SettingKeyEpayDefaultCurrency, Value: "cny", Type: mdb.SettingTypeString},
-		{Group: mdb.SettingGroupEpay, Key: mdb.SettingKeyEpayDefaultNetwork, Value: "tron", Type: mdb.SettingTypeString},
+		{Group: mdb.SettingGroupEpay, Key: mdb.SettingKeyEpayDefaultNetwork, Value: "", Type: mdb.SettingTypeString},
 		{Group: mdb.SettingGroupOkPay, Key: mdb.SettingKeyOkPayEnabled, Value: "false", Type: mdb.SettingTypeBool},
 		{Group: mdb.SettingGroupOkPay, Key: mdb.SettingKeyOkPayAPIURL, Value: "https://api.okaypay.me/shop/", Type: mdb.SettingTypeString},
 		{Group: mdb.SettingGroupOkPay, Key: mdb.SettingKeyOkPayCallbackURL, Value: okPayCallbackURL, Type: mdb.SettingTypeString},

src/model/dao/mdb_table_init_test.go

@@ -1,9 +1,14 @@
 package dao
 
 import (
+	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/GMWalletApp/epusdt/model/mdb"
+	"github.com/libtnb/sqlite"
+	"github.com/spf13/viper"
+	"gorm.io/gorm"
 )
 
 func TestDefaultRpcNodesIncludesManualVerifyEpusdtEvmNodes(t *testing.T) {
@@ -41,3 +46,242 @@ func TestDefaultRpcNodesIncludesManualVerifyEpusdtEvmNodes(t *testing.T) {
 		}
 	}
 }
+
+func TestDefaultRpcNodesIncludesTonLiteGeneralNode(t *testing.T) {
+	var got *mdb.RpcNode
+	nodes := defaultRpcNodes()
+	for i := range nodes {
+		node := nodes[i]
+		if node.Network == mdb.NetworkTon && node.Type == mdb.RpcNodeTypeLite {
+			got = &node
+			break
+		}
+	}
+
+	if got == nil {
+		t.Fatal("missing TON lite seed rpc node")
+	}
+	if got.Url != "https://ton-blockchain.github.io/global.config.json" {
+		t.Fatalf("TON lite seed url = %q", got.Url)
+	}
+	if got.Purpose != mdb.RpcNodePurposeGeneral {
+		t.Fatalf("TON lite seed purpose = %q, want %q", got.Purpose, mdb.RpcNodePurposeGeneral)
+	}
+	if !got.Enabled {
+		t.Fatal("TON lite seed enabled = false, want true")
+	}
+	if got.Status != mdb.RpcNodeStatusUnknown {
+		t.Fatalf("TON lite seed status = %q, want %q", got.Status, mdb.RpcNodeStatusUnknown)
+	}
+}
+
+func TestDefaultRpcNodesIncludesAptosPublicNode(t *testing.T) {
+	var got *mdb.RpcNode
+	nodes := defaultRpcNodes()
+	for i := range nodes {
+		node := nodes[i]
+		if node.Network == mdb.NetworkAptos {
+			got = &node
+			break
+		}
+	}
+
+	if got == nil {
+		t.Fatal("missing Aptos seed rpc node")
+	}
+	if got.Url != "https://aptos-rest.publicnode.com/" {
+		t.Fatalf("Aptos seed url = %q", got.Url)
+	}
+	if got.Type != mdb.RpcNodeTypeHttp {
+		t.Fatalf("Aptos seed type = %q, want %q", got.Type, mdb.RpcNodeTypeHttp)
+	}
+	if got.Purpose != mdb.RpcNodePurposeGeneral {
+		t.Fatalf("Aptos seed purpose = %q, want %q", got.Purpose, mdb.RpcNodePurposeGeneral)
+	}
+	if !got.Enabled {
+		t.Fatal("Aptos seed enabled = false, want true")
+	}
+	if got.Status != mdb.RpcNodeStatusUnknown {
+		t.Fatalf("Aptos seed status = %q, want %q", got.Status, mdb.RpcNodeStatusUnknown)
+	}
+}
+
+func TestSeedChainsIncludesAptos(t *testing.T) {
+	db := setupSeedTableTestDB(t, &mdb.Chain{})
+	Mdb = db
+
+	seedChains()
+
+	var row mdb.Chain
+	if err := Mdb.Where("network = ?", mdb.NetworkAptos).Take(&row).Error; err != nil {
+		t.Fatalf("load Aptos chain seed: %v", err)
+	}
+	if !row.Enabled {
+		t.Fatal("Aptos chain enabled = false, want true")
+	}
+}
+
+func TestSeedChainTokensIncludesAptosAssets(t *testing.T) {
+	db := setupSeedTableTestDB(t, &mdb.ChainToken{})
+	Mdb = db
+
+	seedChainTokens()
+
+	wantEnabled := map[string]bool{
+		mdb.NetworkAptos + "/USDC": true,
+		mdb.NetworkAptos + "/USDT": true,
+	}
+	wantContract := map[string]string{
+		mdb.NetworkAptos + "/USDT": "0x357b0b74bc833e95a115ad22604854d6b0fca151cecd94111770e5d6ffc9dc2b",
+	}
+	for key, enabled := range wantEnabled {
+		parts := strings.Split(key, "/")
+		var row mdb.ChainToken
+		if err := Mdb.Where("network = ? AND symbol = ?", parts[0], parts[1]).Take(&row).Error; err != nil {
+			t.Fatalf("load token seed %s: %v", key, err)
+		}
+		if row.Enabled != enabled {
+			t.Fatalf("%s enabled = %v, want %v", key, row.Enabled, enabled)
+		}
+		if want, ok := wantContract[key]; ok && row.ContractAddress != want {
+			t.Fatalf("%s contract_address = %q, want %q", key, row.ContractAddress, want)
+		}
+	}
+}
+
+func TestSeedDefaultSettingsIncludesSystemLogLevel(t *testing.T) {
+	db := setupSeedSettingsTestDB(t)
+	Mdb = db
+
+	seedDefaultSettings()
+
+	var row mdb.Setting
+	if err := Mdb.Where("`key` = ?", mdb.SettingKeySystemLogLevel).Take(&row).Error; err != nil {
+		t.Fatalf("load system.log_level seed: %v", err)
+	}
+	if row.Group != mdb.SettingGroupSystem {
+		t.Fatalf("system.log_level group = %q, want %q", row.Group, mdb.SettingGroupSystem)
+	}
+	if row.Value != mdb.SettingDefaultSystemLogLevel {
+		t.Fatalf("system.log_level value = %q, want %q", row.Value, mdb.SettingDefaultSystemLogLevel)
+	}
+	if row.Type != mdb.SettingTypeString {
+		t.Fatalf("system.log_level type = %q, want %q", row.Type, mdb.SettingTypeString)
+	}
+}
+
+func TestSeedDefaultSettingsUsesEmptyEpayTokenAndNetwork(t *testing.T) {
+	db := setupSeedSettingsTestDB(t)
+	Mdb = db
+
+	seedDefaultSettings()
+
+	rows := make(map[string]mdb.Setting)
+	for _, key := range []string{
+		mdb.SettingKeyEpayDefaultToken,
+		mdb.SettingKeyEpayDefaultCurrency,
+		mdb.SettingKeyEpayDefaultNetwork,
+	} {
+		var row mdb.Setting
+		if err := Mdb.Where("`key` = ?", key).Take(&row).Error; err != nil {
+			t.Fatalf("load %s seed: %v", key, err)
+		}
+		rows[key] = row
+	}
+	if rows[mdb.SettingKeyEpayDefaultToken].Value != "" {
+		t.Fatalf("epay.default_token seed = %q, want empty", rows[mdb.SettingKeyEpayDefaultToken].Value)
+	}
+	if rows[mdb.SettingKeyEpayDefaultNetwork].Value != "" {
+		t.Fatalf("epay.default_network seed = %q, want empty", rows[mdb.SettingKeyEpayDefaultNetwork].Value)
+	}
+	if rows[mdb.SettingKeyEpayDefaultCurrency].Value != "cny" {
+		t.Fatalf("epay.default_currency seed = %q, want cny", rows[mdb.SettingKeyEpayDefaultCurrency].Value)
+	}
+}
+
+func TestSeedDefaultSettingsDoesNotOverwriteExistingEpayDefaults(t *testing.T) {
+	db := setupSeedSettingsTestDB(t)
+	Mdb = db
+	for _, row := range []mdb.Setting{
+		{Group: mdb.SettingGroupEpay, Key: mdb.SettingKeyEpayDefaultToken, Value: "usdt", Type: mdb.SettingTypeString},
+		{Group: mdb.SettingGroupEpay, Key: mdb.SettingKeyEpayDefaultNetwork, Value: "tron", Type: mdb.SettingTypeString},
+	} {
+		if err := Mdb.Create(&row).Error; err != nil {
+			t.Fatalf("precreate %s: %v", row.Key, err)
+		}
+	}
+
+	seedDefaultSettings()
+
+	for key, want := range map[string]string{
+		mdb.SettingKeyEpayDefaultToken:   "usdt",
+		mdb.SettingKeyEpayDefaultNetwork: "tron",
+	} {
+		var row mdb.Setting
+		if err := Mdb.Where("`key` = ?", key).Take(&row).Error; err != nil {
+			t.Fatalf("load %s seed: %v", key, err)
+		}
+		if row.Value != want {
+			t.Fatalf("%s value = %q, want existing %q", key, row.Value, want)
+		}
+	}
+}
+
+func TestSeedDefaultSettingsDoesNotOverwriteSystemLogLevel(t *testing.T) {
+	db := setupSeedSettingsTestDB(t)
+	Mdb = db
+	if err := Mdb.Create(&mdb.Setting{
+		Group: mdb.SettingGroupSystem,
+		Key:   mdb.SettingKeySystemLogLevel,
+		Value: "debug",
+		Type:  mdb.SettingTypeString,
+	}).Error; err != nil {
+		t.Fatalf("precreate system.log_level: %v", err)
+	}
+
+	seedDefaultSettings()
+
+	var row mdb.Setting
+	if err := Mdb.Where("`key` = ?", mdb.SettingKeySystemLogLevel).Take(&row).Error; err != nil {
+		t.Fatalf("load system.log_level seed: %v", err)
+	}
+	if row.Value != "debug" {
+		t.Fatalf("system.log_level value = %q, want existing debug", row.Value)
+	}
+}
+
+func setupSeedSettingsTestDB(t *testing.T) *gorm.DB {
+	t.Helper()
+	oldDB := Mdb
+	viper.Reset()
+	viper.Set("app_uri", "https://example.com")
+	t.Cleanup(func() {
+		Mdb = oldDB
+		viper.Reset()
+	})
+
+	db, err := gorm.Open(sqlite.Open(filepath.Join(t.TempDir(), "seed-settings.db")), &gorm.Config{})
+	if err != nil {
+		t.Fatalf("open sqlite: %v", err)
+	}
+	if err := db.AutoMigrate(&mdb.Setting{}); err != nil {
+		t.Fatalf("migrate settings: %v", err)
+	}
+	return db
+}
+
+func setupSeedTableTestDB(t *testing.T, models ...interface{}) *gorm.DB {
+	t.Helper()
+	oldDB := Mdb
+	t.Cleanup(func() {
+		Mdb = oldDB
+	})
+	db, err := gorm.Open(sqlite.Open(filepath.Join(t.TempDir(), "seed-table.db")), &gorm.Config{})
+	if err != nil {
+		t.Fatalf("open sqlite: %v", err)
+	}
+	if err := db.AutoMigrate(models...); err != nil {
+		t.Fatalf("migrate seed table: %v", err)
+	}
+	return db
+}

src/model/data/order_admin_data.go

@@ -105,12 +105,12 @@ func CountOrdersByStatus() (map[int]int64, error) {
 	return out, nil
 }
 
-// CloseOrderManually transitions a pending order to expired. Only
+// CloseOrderManually transitions a pending order to expired. It covers both
-// touches rows currently in StatusWaitPay so idempotent / safe.
+// payable orders and placeholder orders waiting for token/network selection.
 func CloseOrderManually(tradeID string) (bool, error) {
 	result := dao.Mdb.Model(&mdb.Orders{}).
 		Where("trade_id = ?", tradeID).
-		Where("status = ?", mdb.StatusWaitPay).
+		Where("status IN ?", []int{mdb.StatusWaitPay, mdb.StatusWaitSelect}).
 		Update("status", mdb.StatusExpired)
 	return result.RowsAffected > 0, result.Error
 }

src/model/data/order_data.go

@@ -8,6 +8,7 @@ import (
 	"github.com/GMWalletApp/epusdt/model/dao"
 	"github.com/GMWalletApp/epusdt/model/mdb"
 	"github.com/GMWalletApp/epusdt/model/request"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
 	"github.com/dromara/carbon/v2"
 	"github.com/shopspring/decimal"
 	"gorm.io/gorm"
@@ -39,9 +40,20 @@ func normalizeLockNetwork(network string) string {
 
 func normalizeLockAddress(network, address string) string {
 	address = strings.TrimSpace(address)
-	if isEVMNetwork(normalizeLockNetwork(network)) {
+	network = normalizeLockNetwork(network)
+	if isEVMNetwork(network) {
 		return strings.ToLower(address)
 	}
+	if network == mdb.NetworkTon {
+		if raw, err := addressutil.TonRawAddressKey(address); err == nil {
+			return raw
+		}
+	}
+	if network == mdb.NetworkAptos {
+		if normalized, err := addressutil.NormalizeMoveAddress(address); err == nil {
+			return normalized
+		}
+	}
 	return address
 }
 
@@ -202,7 +214,7 @@ func SaveCallBackOrdersResp(order *mdb.Orders) error {
 func UpdateOrderIsExpirationById(id uint64, expirationCutoff time.Time) (bool, error) {
 	result := dao.Mdb.Model(mdb.Orders{}).
 		Where("id = ?", id).
-		Where("status = ?", mdb.StatusWaitPay).
+		Where("status IN ?", []int{mdb.StatusWaitPay, mdb.StatusWaitSelect}).
 		Where("created_at <= ?", expirationCutoff).
 		Update("status", mdb.StatusExpired)
 	return result.RowsAffected > 0, result.Error
@@ -218,6 +230,15 @@ func CountActiveSubOrders(parentTradeId string) (int64, error) {
 	return count, err
 }
 
+// CountSubOrders counts all sub-orders ever created under a parent.
+func CountSubOrders(parentTradeId string) (int64, error) {
+	var count int64
+	err := dao.Mdb.Model(&mdb.Orders{}).
+		Where("parent_trade_id = ?", parentTradeId).
+		Count(&count).Error
+	return count, err
+}
+
 // GetSubOrderByTokenNetwork finds an existing active sub-order matching token+network under a parent.
 func GetSubOrderByTokenNetwork(parentTradeId string, token string, network string) (*mdb.Orders, error) {
 	order := new(mdb.Orders)
@@ -281,6 +302,61 @@ func MarkOrderSelected(tradeId string) error {
 		Update("is_selected", true).Error
 }
 
+// CompleteWaitSelectOrder fills a placeholder order with concrete chain fields
+// and makes it payable. It only updates status=WaitSelect rows so concurrent
+// switch-network attempts cannot overwrite a payable order.
+func CompleteWaitSelectOrder(tradeID string, network string, token string, receiveAddress string, actualAmount float64) (bool, error) {
+	result := dao.Mdb.Model(&mdb.Orders{}).
+		Where("trade_id = ?", tradeID).
+		Where("status = ?", mdb.StatusWaitSelect).
+		Updates(map[string]interface{}{
+			"status":          mdb.StatusWaitPay,
+			"network":         strings.ToLower(strings.TrimSpace(network)),
+			"token":           strings.ToUpper(strings.TrimSpace(token)),
+			"receive_address": receiveAddress,
+			"actual_amount":   actualAmount,
+			"is_selected":     false,
+			"created_at":      time.Now(),
+		})
+	return result.RowsAffected > 0, result.Error
+}
+
+// CompleteWaitSelectOkPayOrderWithTransaction converts a placeholder parent
+// directly into an OkPay order. It intentionally does not create a local chain
+// lock because OkPay owns the hosted payment target.
+func CompleteWaitSelectOkPayOrderWithTransaction(tx *gorm.DB, tradeID string, token string, actualAmount float64) (bool, error) {
+	result := tx.Model(&mdb.Orders{}).
+		Where("trade_id = ?", tradeID).
+		Where("status = ?", mdb.StatusWaitSelect).
+		Updates(map[string]interface{}{
+			"status":          mdb.StatusWaitPay,
+			"network":         mdb.PaymentProviderOkPay,
+			"token":           strings.ToUpper(strings.TrimSpace(token)),
+			"receive_address": "OKPAY",
+			"actual_amount":   actualAmount,
+			"is_selected":     false,
+			"pay_provider":    mdb.PaymentProviderOkPay,
+			"created_at":      time.Now(),
+		})
+	return result.RowsAffected > 0, result.Error
+}
+
+// MarkProviderSwitchParentSelectedWithTransaction marks a switch-network parent
+// as selected for a hosted payment provider. It intentionally does not fill
+// chain fields or create a transaction lock; the provider child order carries
+// the concrete payment target.
+func MarkProviderSwitchParentSelectedWithTransaction(tx *gorm.DB, tradeID string) (bool, error) {
+	result := tx.Model(&mdb.Orders{}).
+		Where("trade_id = ?", tradeID).
+		Where("status IN ?", []int{mdb.StatusWaitPay, mdb.StatusWaitSelect}).
+		Updates(map[string]interface{}{
+			"status":      mdb.StatusWaitPay,
+			"is_selected": true,
+			"created_at":  time.Now(),
+		})
+	return result.RowsAffected > 0, result.Error
+}
+
 // ExpireOrderByTradeID marks a waiting order as expired. Used to retire failed
 // child-order attempts that should not remain selectable/reusable.
 func ExpireOrderByTradeID(tradeId string) error {

src/model/data/order_data_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/GMWalletApp/epusdt/internal/testutil"
 	"github.com/GMWalletApp/epusdt/model/mdb"
+	"github.com/xssnick/tonutils-go/address"
 )
 
 func TestEvmTransactionLockAddressIsCaseInsensitive(t *testing.T) {
@@ -156,3 +157,46 @@ func TestNonEvmTransactionLockAddressRemainsCaseSensitive(t *testing.T) {
 		t.Fatalf("tron address lookup should remain case-sensitive, got trade id %q", gotTradeID)
 	}
 }
+
+func TestTonTransactionLockAddressUsesRawKey(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	bounceable := "EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I"
+	addr := address.MustParseAddr(bounceable)
+	nonBounce := addr.Bounce(false).String()
+
+	if err := LockTransaction(mdb.NetworkTon, bounceable, "TON", "trade-ton", 1.23, time.Hour); err != nil {
+		t.Fatalf("lock ton transaction: %v", err)
+	}
+	gotTradeID, err := GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkTon, nonBounce, "TON", 1.23)
+	if err != nil {
+		t.Fatalf("lookup ton lock: %v", err)
+	}
+	if gotTradeID != "trade-ton" {
+		t.Fatalf("ton lock lookup = %q, want trade-ton", gotTradeID)
+	}
+	gotTradeID, err = GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkTon, addr.StringRaw(), "TON", 1.23)
+	if err != nil {
+		t.Fatalf("lookup ton raw lock: %v", err)
+	}
+	if gotTradeID != "trade-ton" {
+		t.Fatalf("ton raw lock lookup = %q, want trade-ton", gotTradeID)
+	}
+}
+
+func TestAptosTransactionLockAddressUsesCanonicalKey(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := LockTransaction(mdb.NetworkAptos, "0xA", "USDT", "trade-aptos", 1.23, time.Hour); err != nil {
+		t.Fatalf("lock aptos transaction: %v", err)
+	}
+	gotTradeID, err := GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkAptos, "a", "USDT", 1.23)
+	if err != nil {
+		t.Fatalf("lookup aptos lock: %v", err)
+	}
+	if gotTradeID != "trade-aptos" {
+		t.Fatalf("aptos lock lookup = %q, want trade-aptos", gotTradeID)
+	}
+}

src/model/data/provider_order_data.go

@@ -4,6 +4,7 @@ import (
 	"github.com/GMWalletApp/epusdt/model/dao"
 	"github.com/GMWalletApp/epusdt/model/mdb"
 	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
 )
 
 func GetProviderOrderByTradeIDAndProvider(tradeID string, provider string) (*mdb.ProviderOrder, error) {
@@ -20,8 +21,27 @@ func CreateProviderOrderWithTransaction(tx *gorm.DB, row *mdb.ProviderOrder) err
 	return tx.Model(row).Create(row).Error
 }
 
+func UpsertProviderOrderCreatingWithTransaction(tx *gorm.DB, row *mdb.ProviderOrder) error {
+	return tx.Clauses(clause.OnConflict{
+		Columns: []clause.Column{{Name: "trade_id"}, {Name: "provider"}},
+		DoUpdates: clause.AssignmentColumns([]string{
+			"provider_order_id",
+			"pay_url",
+			"amount",
+			"coin",
+			"status",
+			"notify_raw",
+			"updated_at",
+		}),
+	}).Create(row).Error
+}
+
 func UpdateProviderOrderCreated(tradeID string, provider string, providerOrderID string, payURL string) error {
-	return dao.Mdb.Model(&mdb.ProviderOrder{}).
+	return UpdateProviderOrderCreatedWithTransaction(dao.Mdb, tradeID, provider, providerOrderID, payURL)
+}
+
+func UpdateProviderOrderCreatedWithTransaction(tx *gorm.DB, tradeID string, provider string, providerOrderID string, payURL string) error {
+	return tx.Model(&mdb.ProviderOrder{}).
 		Where("trade_id = ?", tradeID).
 		Where("provider = ?", provider).
 		Updates(map[string]interface{}{

src/model/data/wallet_address_data.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/GMWalletApp/epusdt/model/dao"
 	"github.com/GMWalletApp/epusdt/model/mdb"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
 	"github.com/GMWalletApp/epusdt/util/constant"
 )
 
@@ -34,10 +35,26 @@ func normalizeWalletAddressByNetwork(network, address string) string {
 	return address
 }
 
+func normalizeWalletAddressByNetworkE(network, address string) (string, error) {
+	network = normalizeWalletNetwork(network)
+	address = strings.TrimSpace(address)
+	if network == mdb.NetworkTon {
+		return addressutil.NormalizeTonAddress(address)
+	}
+	if network == mdb.NetworkAptos {
+		return addressutil.NormalizeMoveAddress(address)
+	}
+	return normalizeWalletAddressByNetwork(network, address), nil
+}
+
 // AddWalletAddressWithNetwork 创建指定网络的钱包地址
 func AddWalletAddressWithNetwork(network, address string) (*mdb.WalletAddress, error) {
 	network = normalizeWalletNetwork(network)
-	address = normalizeWalletAddressByNetwork(network, address)
+	var err error
+	address, err = normalizeWalletAddressByNetworkE(network, address)
+	if err != nil {
+		return nil, err
+	}
 
 	exist, err := GetWalletAddressByNetworkAndAddress(network, address)
 	if err != nil {
@@ -75,9 +92,13 @@ func AddWalletAddressWithNetwork(network, address string) (*mdb.WalletAddress, e
 // GetWalletAddressByNetworkAndAddress 通过网络和地址查询
 func GetWalletAddressByNetworkAndAddress(network, address string) (*mdb.WalletAddress, error) {
 	network = normalizeWalletNetwork(network)
-	address = normalizeWalletAddressByNetwork(network, address)
+	var err error
+	address, err = normalizeWalletAddressByNetworkE(network, address)
+	if err != nil {
+		return nil, err
+	}
 	walletAddress := new(mdb.WalletAddress)
-	err := dao.Mdb.Model(walletAddress).
+	err = dao.Mdb.Model(walletAddress).
 		Where("network = ?", network).
 		Where("address = ?", address).
 		Limit(1).Find(walletAddress).Error
@@ -126,6 +147,12 @@ func GetAvailableWalletAddressByNetwork(network string) ([]mdb.WalletAddress, er
 		for i := range list {
 			list[i].Address = strings.ToLower(strings.TrimSpace(list[i].Address))
 		}
+	} else if network == mdb.NetworkTon {
+		for i := range list {
+			if normalized, err := addressutil.NormalizeTonAddress(list[i].Address); err == nil {
+				list[i].Address = normalized
+			}
+		}
 	}
 	return list, err
 }
@@ -149,6 +176,12 @@ func GetAllWalletAddressByNetwork(network string) ([]mdb.WalletAddress, error) {
 		for i := range list {
 			list[i].Address = strings.ToLower(strings.TrimSpace(list[i].Address))
 		}
+	} else if network == mdb.NetworkTon {
+		for i := range list {
+			if normalized, err := addressutil.NormalizeTonAddress(list[i].Address); err == nil {
+				list[i].Address = normalized
+			}
+		}
 	}
 	return list, err
 }

src/model/data/wallet_address_data_test.go

@@ -7,6 +7,8 @@ import (
 	"github.com/GMWalletApp/epusdt/internal/testutil"
 	"github.com/GMWalletApp/epusdt/model/dao"
 	"github.com/GMWalletApp/epusdt/model/mdb"
+	"github.com/GMWalletApp/epusdt/util/constant"
+	"github.com/xssnick/tonutils-go/address"
 )
 
 func TestAddWalletAddressWithNetworkNormalizesEvmAddressToLowercase(t *testing.T) {
@@ -81,3 +83,40 @@ func TestAddWalletAddressWithNetworkKeepsOriginalCaseForNonEvm(t *testing.T) {
 		t.Fatalf("solana wallet address = %q, want %q", solRow.Address, solAddress)
 	}
 }
+
+func TestAddWalletAddressWithNetworkNormalizesTonAddressVariants(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	bounceable := "EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I"
+	addr := address.MustParseAddr(bounceable)
+	expected := addr.Bounce(false).String()
+
+	row, err := AddWalletAddressWithNetwork(mdb.NetworkTon, addr.StringRaw())
+	if err != nil {
+		t.Fatalf("add raw ton wallet: %v", err)
+	}
+	if row.Address != expected {
+		t.Fatalf("stored TON address = %q, want %q", row.Address, expected)
+	}
+	if _, err = AddWalletAddressWithNetwork(mdb.NetworkTon, bounceable); err != constant.WalletAddressAlreadyExists {
+		t.Fatalf("add equivalent ton wallet error = %v, want already exists", err)
+	}
+}
+
+func TestAddWalletAddressWithNetworkNormalizesMoveAddressVariants(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	want := "0x000000000000000000000000000000000000000000000000000000000000000a"
+	row, err := AddWalletAddressWithNetwork(mdb.NetworkAptos, " A ")
+	if err != nil {
+		t.Fatalf("add aptos wallet: %v", err)
+	}
+	if row.Address != want {
+		t.Fatalf("stored Aptos address = %q, want %q", row.Address, want)
+	}
+	if _, err = AddWalletAddressWithNetwork(mdb.NetworkAptos, "0x0A"); err != constant.WalletAddressAlreadyExists {
+		t.Fatalf("add equivalent aptos wallet error = %v, want already exists", err)
+	}
+}

src/model/mdb/chain_token.go

@@ -5,10 +5,11 @@ const (
 	ChainTokenStatusDisable = 2
 )
 
-// ChainToken describes a token to watch on a given chain. Replaces the
+// ChainToken describes a token to watch on a given chain. For EVM/TRON rows
-// hardcoded USDT/USDC contract addresses in task/listen_eth.go. Scanners
+// ContractAddress is the token contract; for Solana it is the mint; for
-// load this table on startup (and refresh periodically) to learn which
+// TON it is the jetton master; for Aptos it is the Move asset identifier
-// contracts to subscribe to.
+// (coin type, metadata address or object type). Native rows use an empty
+// ContractAddress.
 type ChainToken struct {
 	Network         string  `gorm:"column:network;size:32;uniqueIndex:chain_tokens_network_symbol_uindex,priority:1" json:"network" example:"tron"`
 	Symbol          string  `gorm:"column:symbol;size:32;uniqueIndex:chain_tokens_network_symbol_uindex,priority:2" json:"symbol" example:"USDT"`

src/model/mdb/orders_mdb.go

@@ -4,12 +4,21 @@ const (
 	StatusWaitPay    = 1
 	StatusPaySuccess = 2
 	StatusExpired    = 3
+	// StatusWaitSelect is a placeholder order waiting for the payer to choose
+	// token+network or a hosted provider such as OkPay. It is not payable until
+	// switch-network moves it to StatusWaitPay.
+	StatusWaitSelect  = 4
 	CallBackConfirmOk = 1
 	CallBackConfirmNo = 2
 )
 
 const (
+	// PaymentTypeEpay is the normalized special payment_type value. Orders
+	// matching it case-insensitively use the legacy EPay callback shape.
 	PaymentTypeEpay = "Epay"
+	// PaymentTypeGmpay is the normalized default for GMPay-created orders.
+	// It uses the default GMPay JSON callback shape.
+	PaymentTypeGmpay = "Gmpay"
 )
 
 const (
@@ -19,9 +28,10 @@ const (
 	// PaymentProviderOkPay means this concrete order record is settled through
 	// the third-party OkayPay/OkPay hosted checkout flow.
 	//
-	// In the current design this is typically used by a switch-network-created
+	// It can be used by a status=4 parent completed in place on first
-	// child order, while the parent order keeps its original merchant-facing
+	// switch-network, or by a switch-network-created child order after the
-	// semantics and callback behavior.
+	// parent is already concrete. Merchant callback shape is still controlled by
+	// PaymentType, not by this provider value.
 	PaymentProviderOkPay = "okpay"
 )
 
@@ -36,8 +46,8 @@ type Orders struct {
 	ReceiveAddress     string  `gorm:"column:receive_address" json:"receive_address" example:"TTestTronAddress001"`
 	Token              string  `gorm:"column:token" json:"token" example:"USDT"`
 	Network            string  `gorm:"column:network" json:"network" example:"tron"`
-	// 订单状态 1=等待支付 2=支付成功 3=已过期
+	// 订单状态 1=等待支付 2=支付成功 3=已过期 4=等待选择支付网络/币种
-	Status      int    `gorm:"column:status;default:1" json:"status" enums:"1,2,3" example:"1"`
+	Status      int    `gorm:"column:status;default:1" json:"status" enums:"1,2,3,4" example:"1"`
 	NotifyUrl   string `gorm:"column:notify_url" json:"notify_url" example:"https://example.com/notify"`
 	RedirectUrl string `gorm:"column:redirect_url" json:"redirect_url" example:"https://example.com/success"`
 	Name        string `gorm:"column:name" json:"name" example:"VIP月卡"`
@@ -45,12 +55,14 @@ type Orders struct {
 	// 回调确认状态 1=回调成功 2=未回调/回调失败
 	CallBackConfirm int  `gorm:"column:callback_confirm;default:2" json:"callback_confirm" enums:"1,2" example:"2"`
 	IsSelected      bool `gorm:"column:is_selected;default:false" json:"is_selected" example:"false"`
+	// PaymentType is not a channel selector. "Epay" changes callback format
+	// to legacy EPay case-insensitively; "Gmpay" uses GMPay JSON.
 	PaymentType string `gorm:"column:payment_type" json:"payment_type" example:"Epay"`
 	// PayProvider identifies how this specific order row is collected.
 	//
 	// Semantics:
-	//   - parent orders and regular chain child orders use on_chain
+	//   - chain parent orders and regular chain child orders use on_chain
-	//   - third-party hosted checkout child orders use their provider name
+	//   - third-party hosted checkout rows use their provider name
 	//     (for example okpay)
 	//
 	// Existing rows default to on_chain for backward compatibility so upgrades

src/model/mdb/provider_order.go

@@ -9,8 +9,8 @@ const (
 )
 
 // ProviderOrder stores provider-specific checkout data for one internal order
-// row. For OkPay this is expected to bind to the concrete child order created
+// row. For OkPay this can bind either to a status=4 parent completed in place
-// by switch-network, not to the parent merchant order.
+// or to a concrete child order created by later switch-network calls.
 //
 // Binding rules:
 //   - trade_id always points to orders.trade_id

src/model/mdb/rpc_node.go

@@ -5,6 +5,7 @@ import "github.com/dromara/carbon/v2"
 const (
 	RpcNodeTypeHttp = "http"
 	RpcNodeTypeWs   = "ws"
+	RpcNodeTypeLite = "lite"
 )
 
 const (
@@ -24,8 +25,8 @@ const (
 type RpcNode struct {
 	Network string `gorm:"column:network;size:32;index:rpc_nodes_network_status_index,priority:1" json:"network" example:"tron"`
 	Url     string `gorm:"column:url;size:512" json:"url" example:"https://api.trongrid.io"`
-	// 连接类型 http=HTTP请求 ws=WebSocket长连接
+	// 连接类型 http=HTTP请求 ws=WebSocket长连接 lite=TON liteserver配置
-	Type    string `gorm:"column:type;size:16" json:"type" enums:"http,ws" example:"http"`
+	Type    string `gorm:"column:type;size:16" json:"type" enums:"http,ws,lite" example:"http"`
 	Weight  int    `gorm:"column:weight;default:1" json:"weight" example:"1"`
 	ApiKey  string `gorm:"column:api_key;size:255" json:"api_key" example:"your-api-key"`
 	Enabled bool   `gorm:"column:enabled;default:true" json:"enabled" example:"true"`

src/model/mdb/settings.go

@@ -4,10 +4,10 @@ package mdb
 // Groups: brand, rate, system, epay, okpay. Merchant credentials (pid +
 // secret_key) live in the api_keys table; notification configs live in
 // NotificationChannel.
-// Default rows for the epay/okpay groups are seeded on first startup (see
+// Default rows for the system/epay/okpay groups are seeded on first startup
-// model/dao/mdb_table_init.go seedDefaultSettings). All other groups start
+// (see model/dao/mdb_table_init.go seedDefaultSettings). Other groups start
-// empty and fall back to hardcoded defaults until an admin sets them.
+// empty and fall back to hardcoded defaults until an admin sets them. The
-// Only exception: system.jwt_secret is auto-generated on first startup.
+// system.jwt_secret key is auto-generated on first startup.
 const (
 	SettingGroupBrand  = "brand"
 	SettingGroupRate   = "rate"
@@ -31,6 +31,7 @@ const (
 	SettingKeyInitAdminPasswordChanged = "system.init_admin_password_changed"
 	SettingKeyOrderExpiration          = "system.order_expiration_time"
 	SettingKeyAmountPrecision          = "system.amount_precision"
+	SettingKeySystemLogLevel           = "system.log_level"
 	SettingKeyBrandCheckoutName        = "brand.checkout_name"
 	SettingKeyBrandSiteName            = "brand.site_name"
 	SettingKeyBrandLogoUrl             = "brand.logo_url"
@@ -62,6 +63,10 @@ const (
 	SettingKeyOkPayAllowTokens    = "okpay.allow_tokens"
 )
 
+const (
+	SettingDefaultSystemLogLevel = "error"
+)
+
 type Setting struct {
 	Group       string `gorm:"column:group;size:32;index:settings_group_index" json:"group" enums:"brand,rate,system,epay,okpay" example:"rate"`
 	Key         string `gorm:"column:key;uniqueIndex:settings_key_uindex;size:128" json:"key" example:"rate.forced_rate_list"`

src/model/mdb/wallet_address_mdb.go

@@ -12,6 +12,8 @@ const (
 	NetworkBsc      = "binance"
 	NetworkPolygon  = "polygon"
 	NetworkPlasma   = "plasma"
+	NetworkTon      = "ton"
+	NetworkAptos    = "aptos"
 )
 
 const (

src/model/request/order_request.go

@@ -6,13 +6,17 @@ import "github.com/gookit/validate"
 type CreateTransactionRequest struct {
 	OrderId     string  `json:"order_id" form:"order_id" validate:"required|maxLen:32" example:"ORD20260416001"`
 	Currency    string  `json:"currency" form:"currency" validate:"required" example:"cny"` // 法币 如：cny
-	Token       string  `json:"token" form:"token" validate:"required" example:"usdt"`      // 币种 如：usdt
+	Token       string  `json:"token" form:"token" example:"usdt"`                          // 币种 如：usdt、ton；可与 network 同时缺省创建占位订单
-	Network     string  `json:"network" form:"network" validate:"required" example:"tron"`  // 网络 如：tron
+	Network     string  `json:"network" form:"network" example:"tron"`                      // 网络 如：ton、tron、aptos；可与 token 同时缺省创建占位订单
 	Amount      float64 `json:"amount" form:"amount" validate:"required|isFloat|gt:0.01" example:"100.00"`
 	NotifyUrl   string  `json:"notify_url" form:"notify_url" validate:"required" example:"https://example.com/notify"`
 	Signature   string  `json:"signature" form:"signature" validate:"required" example:"a1b2c3d4e5f6..."`
 	RedirectUrl string  `json:"redirect_url" form:"redirect_url" example:"https://example.com/success"`
 	Name        string  `json:"name" form:"name" example:"VIP月卡"`
+	// PaymentType is a compatibility flag, not a gateway selector. Only
+	// "Epay" (case-insensitive) switches callback format to legacy EPay;
+	// empty or any other value is stored as "Gmpay" and uses GMPay JSON.
+	// It is optional for GMPay, but must be included in the signature when sent.
 	PaymentType string `json:"payment_type" form:"payment_type" example:"Epay"`
 }
 
@@ -54,7 +58,7 @@ func (r ManualPaymentRequest) Translates() map[string]string {
 type SwitchNetworkRequest struct {
 	TradeId string `json:"trade_id" validate:"required" example:"3nQ9pL2xV7sK1mR8cT4yB_aZ"`
 	Token   string `json:"token" validate:"required" example:"USDT"`
-	Network string `json:"network" validate:"required" example:"okpay,tron,solana,ethereum"`
+	Network string `json:"network" validate:"required" example:"okpay,tron,solana,ethereum,aptos"`
 }
 
 func (r SwitchNetworkRequest) Translates() map[string]string {

src/model/response/order_response.go

@@ -9,6 +9,7 @@ type CreateTransactionResponse struct {
 	ActualAmount   float64 `json:"actual_amount" example:"14.2857"`                                                 //  订单实际需要支付的金额，按 system.amount_precision 保留小数
 	ReceiveAddress string  `json:"receive_address" example:"TTestTronAddress001"`                                   //  收款钱包地址
 	Token          string  `json:"token" example:"USDT"`                                                            // 所属币种 TRX USDT......
+	Status         int     `json:"status" enums:"1,2,3,4" example:"1"`                                              // 订单状态 1=等待支付 2=支付成功 3=已过期 4=等待选择支付网络/币种
 	ExpirationTime int64   `json:"expiration_time" example:"1713264600"`                                            // 过期时间 时间戳
 	PaymentUrl     string  `json:"payment_url" example:"https://pay.example.com/checkout/3nQ9pL2xV7sK1mR8cT4yB_aZ"` // 收银台地址
 }

src/model/response/pay_response.go

@@ -3,22 +3,24 @@ package response
 type CheckoutCounterResponse struct {
 	TradeId        string  `json:"trade_id" example:"3nQ9pL2xV7sK1mR8cT4yB_aZ"`                                     //  epusdt订单号
 	Amount         float64 `json:"amount" example:"100.0000"`                                                       //  订单金额，按 system.amount_precision 保留小数 法币金额
-	ActualAmount   float64 `json:"actual_amount" example:"14.2857"`               //  订单实际需要支付的金额，按 system.amount_precision 保留小数 加密货币金额
+	ActualAmount   float64 `json:"actual_amount" example:"14.2857"`                                                 //  订单实际需要支付的金额；status=4 占位订单返回 0
-	Token          string  `json:"token" example:"USDT"`                          //  所属币种 TRX USDT......
+	Token          string  `json:"token" example:"USDT"`                                                            //  所属币种；status=4 占位订单为空
 	Currency       string  `json:"currency" example:"CNY"`                                                          //  法币币种 CNY USD ...
-	ReceiveAddress string  `json:"receive_address" example:"TTestTronAddress001"` //  收款钱包地址
+	ReceiveAddress string  `json:"receive_address" example:"TTestTronAddress001"`                                   //  收款钱包地址；status=4 占位订单为空
-	Network        string  `json:"network" example:"tron"`                        //  网络 TRON ETH ...
+	Network        string  `json:"network" example:"tron"`                                                          //  网络 TRON ETH；status=4 占位订单为空
+	Status         int     `json:"status" enums:"1,2,3,4" example:"1"`                                              // 订单状态 1=等待支付 2=支付成功 3=已过期 4=等待选择支付网络/币种；status=4 时前端应引导选择链上 token/network 或 OkPay
+	PaymentType    string  `json:"payment_type" enums:"gmpay,epay" example:"gmpay"`                                 // 支付接入类型；底层 Epay/Gmpay 转为小写 epay/gmpay 返回
 	ExpirationTime int64   `json:"expiration_time" example:"1713264600"`                                            // 过期时间 时间戳
-	RedirectUrl    string  `json:"redirect_url" example:"https://example.com/success"`
+	RedirectUrl    string  `json:"redirect_url" example:"https://example.com/success"`                              // 非 EPay 时为商户原始回跳地址；EPay 时为内部中转地址 /pay/return/{trade_id}
-	PaymentUrl     string  `json:"payment_url" example:"https://pay.example.com/checkout/3nQ9pL2xV7sK1mR8cT4yB_aZ"` // 支付链接；链上订单通常为本地收银台，OkPay 子订单为第三方 payLink
+	PaymentUrl     string  `json:"payment_url" example:"https://pay.example.com/checkout/3nQ9pL2xV7sK1mR8cT4yB_aZ"` // 支付链接；链上订单为空，OkPay 订单为第三方 payLink
 	CreatedAt      int64   `json:"created_at" example:"1713264000"`                                                 // 订单创建时间 时间戳
-	IsSelected     bool    `json:"is_selected" example:"false"`
+	IsSelected     bool    `json:"is_selected" example:"false"`                                                     // 是否已选择当前支付方式；status=4 占位订单和刚补全的占位父单为 false
 }
 
 type CheckStatusResponse struct {
 	TradeId string `json:"trade_id" example:"3nQ9pL2xV7sK1mR8cT4yB_aZ"` //  epusdt订单号
-	// 订单状态 1=等待支付 2=支付成功 3=已过期
+	// 订单状态 1=等待支付 2=支付成功 3=已过期 4=等待选择支付网络/币种
-	Status int `json:"status" enums:"1,2,3" example:"1"`
+	Status int `json:"status" enums:"1,2,3,4" example:"1"`
 }
 
 type ManualPaymentResponse struct {

src/model/response/support_response.go

@@ -7,9 +7,9 @@ type NetworkTokenSupport struct {
 }
 
 type EpayPublicConfig struct {
-	DefaultToken    string `json:"default_token" example:"usdt"`
+	DefaultToken    string `json:"default_token" example:""`       // EPay default token; empty means submit.php can create a status=4 placeholder when request token/network are also absent.
-	DefaultCurrency string `json:"default_currency" example:"cny"`
+	DefaultCurrency string `json:"default_currency" example:"cny"` // EPay default fiat currency; falls back to cny when unset.
-	DefaultNetwork  string `json:"default_network" example:"tron"`
+	DefaultNetwork  string `json:"default_network" example:""`     // EPay default network; empty means submit.php can create a status=4 placeholder when request token/network are also absent.
 }
 
 type SitePublicConfig struct {

src/model/service/aptos_task.go

@@ -0,0 +1,526 @@
+package service
+
+import (
+	"fmt"
+	"io"
+	"math/big"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
+	"github.com/GMWalletApp/epusdt/util/log"
+	"github.com/tidwall/gjson"
+)
+
+func AptosGetLedgerVersion() (int64, error) {
+	body, err := aptosGet("/v1")
+	if err != nil {
+		return 0, err
+	}
+	latest := gjson.GetBytes(body, "ledger_version").Int()
+	log.Sugar.Debugf("[APTOS] latest ledger version=%d", latest)
+	return latest, nil
+}
+
+func AptosGetTransactionByHash(txID string) ([]byte, error) {
+	txID = normalizeAptosTxID(txID)
+	log.Sugar.Infof("[APTOS] fetch transaction by hash tx=%s", txID)
+	return aptosGet(fmt.Sprintf("/v1/transactions/by_hash/%s", txID))
+}
+
+func AptosGetTransactions(start int64, limit int64) ([]byte, error) {
+	if start < 0 {
+		start = 0
+	}
+	if limit <= 0 {
+		limit = 1
+	}
+	log.Sugar.Debugf("[APTOS] fetch transactions start=%d limit=%d", start, limit)
+	return aptosGet(fmt.Sprintf("/v1/transactions?start=%d&limit=%d", start, limit))
+}
+
+func ParseAptosTransfers(body []byte, address string, tokens []mdb.ChainToken) ([]MoveObservedTransfer, error) {
+	receive, err := addressutil.NormalizeMoveAddress(address)
+	if err != nil {
+		return nil, err
+	}
+	return ParseAptosTransfersForWallets(body, map[string]struct{}{receive: {}}, tokens)
+}
+
+func ParseAptosTransfersForWallets(body []byte, wallets map[string]struct{}, tokens []mdb.ChainToken) ([]MoveObservedTransfer, error) {
+	root := gjson.ParseBytes(body)
+	if !root.IsArray() {
+		return nil, fmt.Errorf("unexpected Aptos transactions response")
+	}
+	var out []MoveObservedTransfer
+	for _, tx := range root.Array() {
+		if tx.Get("type").String() != "" && tx.Get("type").String() != "user_transaction" {
+			continue
+		}
+		if !tx.Get("success").Bool() {
+			continue
+		}
+		txID := strings.TrimSpace(tx.Get("hash").String())
+		if txID == "" {
+			continue
+		}
+		blockTimeMs := parseAptosTimestampMs(tx.Get("timestamp"))
+		version := tx.Get("version").Int()
+		txctx := buildAptosTransferContext(tx)
+		events := buildAptosFungibleEvents(tx, txctx, tokens)
+		deposits := make([]aptosFungibleEvent, 0)
+		withdrawals := make(map[string]int)
+		for _, event := range events {
+			if event.token == nil {
+				continue
+			}
+			switch event.action {
+			case "withdraw":
+				withdrawals[aptosTransferMatchKey(event.token.Symbol, event.rawAmount)]++
+			case "deposit":
+				deposits = append(deposits, event)
+			}
+		}
+		usedDeposits := make([]bool, len(deposits))
+		for i, event := range deposits {
+			matchKey := aptosTransferMatchKey(event.token.Symbol, event.rawAmount)
+			if withdrawals[matchKey] <= 0 {
+				continue
+			}
+			if appendAptosObservedTransfer(&out, txID, version, blockTimeMs, event, wallets) {
+				withdrawals[matchKey]--
+				usedDeposits[i] = true
+			} else {
+				logAptosUnwatchedDeposit(txID, version, event, "direct")
+			}
+		}
+		for i := 0; i < len(deposits); i++ {
+			if usedDeposits[i] {
+				continue
+			}
+			for j := i + 1; j < len(deposits); j++ {
+				if usedDeposits[j] || !aptosDepositPairCanMatch(deposits[i], deposits[j]) {
+					continue
+				}
+				sum := new(big.Int).Add(deposits[i].rawAmount, deposits[j].rawAmount)
+				matchKey := aptosTransferMatchKey(deposits[i].token.Symbol, sum)
+				if withdrawals[matchKey] <= 0 {
+					continue
+				}
+				appendedFirst := appendAptosObservedTransfer(&out, txID, version, blockTimeMs, deposits[i], wallets)
+				appendedSecond := appendAptosObservedTransfer(&out, txID, version, blockTimeMs, deposits[j], wallets)
+				if !appendedFirst && !appendedSecond {
+					logAptosUnwatchedDeposit(txID, version, deposits[i], "split")
+					logAptosUnwatchedDeposit(txID, version, deposits[j], "split")
+					continue
+				}
+				withdrawals[matchKey]--
+				usedDeposits[i] = true
+				usedDeposits[j] = true
+				break
+			}
+		}
+	}
+	return out, nil
+}
+
+func appendAptosObservedTransfer(out *[]MoveObservedTransfer, txID string, version int64, blockTimeMs int64, event aptosFungibleEvent, wallets map[string]struct{}) bool {
+	recipient := event.owner
+	if !moveWalletWatched(recipient, wallets) {
+		return false
+	}
+	*out = append(*out, MoveObservedTransfer{
+		Network:        mdb.NetworkAptos,
+		ReceiveAddress: recipient,
+		Token:          NormalizeAptosPaymentSymbol(event.token.Symbol),
+		RawAmount:      event.rawAmount,
+		Decimals:       event.token.Decimals,
+		MinAmount:      event.token.MinAmount,
+		Amount:         rawToFloat(event.rawAmount, event.token.Decimals),
+		TxID:           normalizeAptosTxID(txID),
+		BlockTimeMs:    blockTimeMs,
+		Version:        version,
+		TransferKey:    moveAptosTransferKey(version, event.eventIndex, recipient, event.token.Symbol, event.rawAmount),
+	})
+	return true
+}
+
+func logAptosUnwatchedDeposit(txID string, version int64, event aptosFungibleEvent, matchMode string) {
+	log.Sugar.Debugf(
+		"[APTOS] matched deposit skipped owner_not_watched mode=%s version=%d tx=%s token=%s amount=%.8f raw=%s owner=%s",
+		matchMode,
+		version,
+		normalizeAptosTxID(txID),
+		NormalizeAptosPaymentSymbol(event.token.Symbol),
+		rawToFloat(event.rawAmount, event.token.Decimals),
+		event.rawAmount.String(),
+		event.owner,
+	)
+}
+
+func aptosDepositPairCanMatch(first, second aptosFungibleEvent) bool {
+	if first.token == nil || second.token == nil || first.rawAmount == nil || second.rawAmount == nil {
+		return false
+	}
+	if NormalizeAptosPaymentSymbol(first.token.Symbol) != NormalizeAptosPaymentSymbol(second.token.Symbol) {
+		return false
+	}
+	return first.token.ContractAddress == second.token.ContractAddress
+}
+
+type aptosFungibleEvent struct {
+	eventIndex int
+	action     string
+	owner      string
+	rawAmount  *big.Int
+	token      *mdb.ChainToken
+}
+
+func buildAptosFungibleEvents(tx gjson.Result, ctx aptosTransferContext, tokens []mdb.ChainToken) []aptosFungibleEvent {
+	out := make([]aptosFungibleEvent, 0)
+	for eventIndex, event := range tx.Get("events").Array() {
+		action := aptosFungibleEventAction(event)
+		if action == "" {
+			continue
+		}
+		rawAmount, ok := parseSignedBigInt(aptosEventRawAmount(event, ctx))
+		if !ok || rawAmount.Sign() <= 0 {
+			continue
+		}
+		token := resolveAptosPaymentToken(aptosEventAssetID(event, ctx), tokens)
+		if token == nil {
+			continue
+		}
+		out = append(out, aptosFungibleEvent{
+			eventIndex: eventIndex,
+			action:     action,
+			owner:      aptosEventRecipient(event, ctx),
+			rawAmount:  rawAmount,
+			token:      token,
+		})
+	}
+	return out
+}
+
+func aptosFungibleEventAction(event gjson.Result) string {
+	typ := strings.ToLower(strings.TrimSpace(event.Get("type").String()))
+	switch typ {
+	case "0x1::fungible_asset::deposit":
+		return "deposit"
+	case "0x1::fungible_asset::withdraw":
+		return "withdraw"
+	default:
+		return ""
+	}
+}
+
+func aptosTransferMatchKey(symbol string, rawAmount *big.Int) string {
+	raw := ""
+	if rawAmount != nil {
+		raw = rawAmount.String()
+	}
+	return NormalizeAptosPaymentSymbol(symbol) + ":" + raw
+}
+
+func resolveAptosPaymentToken(assetID string, tokens []mdb.ChainToken) *mdb.ChainToken {
+	return resolveMoveToken(mdb.NetworkAptos, assetID, tokens)
+}
+
+func NormalizeAptosPaymentSymbol(symbol string) string {
+	return strings.ToUpper(strings.TrimSpace(symbol))
+}
+
+type aptosTransferContext struct {
+	storeOwners   map[string]string
+	storeMetadata map[string]string
+}
+
+func buildAptosTransferContext(tx gjson.Result) aptosTransferContext {
+	ctx := aptosTransferContext{
+		storeOwners:   make(map[string]string),
+		storeMetadata: make(map[string]string),
+	}
+	for _, change := range tx.Get("changes").Array() {
+		if change.Get("type").String() != "write_resource" {
+			continue
+		}
+		store, err := addressutil.NormalizeMoveAddress(change.Get("address").String())
+		if err != nil {
+			continue
+		}
+		changeType := strings.TrimSpace(change.Get("data.type").String())
+		switch changeType {
+		case "0x1::fungible_asset::FungibleStore":
+			if metadata := firstNonEmpty(
+				change.Get("data.data.metadata.inner").String(),
+				change.Get("data.data.metadata").String(),
+			); metadata != "" {
+				ctx.storeMetadata[store] = normalizeAptosObservedAssetID(metadata)
+			}
+		case "0x1::object::ObjectCore":
+			if owner := firstMoveAddress(change.Get("data.data.owner").String()); owner != "" {
+				ctx.storeOwners[store] = owner
+			}
+		}
+	}
+	return ctx
+}
+
+func aptosEventRecipient(event gjson.Result, ctx aptosTransferContext) string {
+	if store := firstMoveAddress(event.Get("data.store").String()); store != "" {
+		if owner := ctx.storeOwners[store]; owner != "" {
+			return owner
+		}
+	}
+	return ""
+}
+
+func aptosEventRawAmount(event gjson.Result, ctx aptosTransferContext) string {
+	return event.Get("data.amount").String()
+}
+
+func aptosEventAssetID(event gjson.Result, ctx aptosTransferContext) string {
+	if store := firstMoveAddress(event.Get("data.store").String()); store != "" {
+		if metadata := ctx.storeMetadata[store]; metadata != "" {
+			return metadata
+		}
+	}
+	return ""
+}
+
+func normalizeAptosObservedAssetID(assetID string) string {
+	return addressutil.NormalizeMoveAssetID(assetID)
+}
+
+func parseAptosTimestampMs(value gjson.Result) int64 {
+	raw := strings.TrimSpace(value.String())
+	if raw == "" {
+		return 0
+	}
+	n, err := strconv.ParseInt(raw, 10, 64)
+	if err != nil {
+		return 0
+	}
+	return n / 1000
+}
+
+func normalizeAptosTxID(txID string) string {
+	txID = strings.ToLower(strings.TrimSpace(txID))
+	if strings.HasPrefix(txID, "0x") {
+		return txID
+	}
+	return "0x" + txID
+}
+
+func ValidateManualAptosPayment(order *mdb.Orders, txID string) (string, error) {
+	txID = normalizeAptosTxID(txID)
+	nodes, err := data.ListManualPaymentRpcCandidates(mdb.NetworkAptos, mdb.RpcNodeTypeHttp)
+	if err != nil {
+		return "", err
+	}
+	if len(nodes) == 0 {
+		return "", fmt.Errorf("no enabled %s %s RPC node configured in rpc_nodes", mdb.NetworkAptos, mdb.RpcNodeTypeHttp)
+	}
+
+	var verifyErrors []string
+	for _, node := range nodes {
+		if strings.TrimSpace(node.Url) == "" {
+			continue
+		}
+		if _, err = validateManualAptosPaymentWithNode(order, txID, node); err != nil {
+			verifyErrors = append(verifyErrors, fmt.Sprintf("%s: %v", data.RpcNodeLogLabel(node), err))
+			continue
+		}
+		return txID, nil
+	}
+	if len(verifyErrors) > 0 {
+		return "", fmt.Errorf("manual Aptos verification failed: %s", strings.Join(verifyErrors, "; "))
+	}
+	return "", fmt.Errorf("no enabled %s %s RPC node configured in rpc_nodes", mdb.NetworkAptos, mdb.RpcNodeTypeHttp)
+}
+
+func validateManualAptosPaymentWithNode(order *mdb.Orders, txID string, node mdb.RpcNode) (string, error) {
+	txID = normalizeAptosTxID(txID)
+	body, err := aptosGetWithNode(node, fmt.Sprintf("/v1/transactions/by_hash/%s", txID))
+	if err != nil {
+		return "", fmt.Errorf("fetch aptos transaction: %w", err)
+	}
+	if err = validateManualAptosTransactionWithConfirm(order, txID, body, func(version int64) error {
+		return ensureAptosTransferConfirmedWithNode(version, node)
+	}); err != nil {
+		return "", err
+	}
+	return txID, nil
+}
+
+func validateManualAptosTransaction(order *mdb.Orders, txID string, body []byte) error {
+	return validateManualAptosTransactionWithConfirm(order, txID, body, EnsureAptosTransferConfirmed)
+}
+
+func validateManualAptosTransactionWithConfirm(order *mdb.Orders, txID string, body []byte, confirm func(int64) error) error {
+	tokens, err := data.ListEnabledChainTokensByNetwork(mdb.NetworkAptos)
+	if err != nil {
+		return err
+	}
+	transfers, err := ParseAptosTransfers([]byte("["+string(body)+"]"), order.ReceiveAddress, tokens)
+	if err != nil {
+		return err
+	}
+	amountMismatch := false
+	for _, transfer := range transfers {
+		if !strings.EqualFold(transfer.TxID, txID) {
+			continue
+		}
+		if err = confirm(transfer.Version); err != nil {
+			return err
+		}
+		if err = EnsureMoveTransferMatchesOrder(order, transfer); err == nil {
+			return nil
+		}
+		if strings.Contains(err.Error(), "amount mismatch") {
+			amountMismatch = true
+		} else {
+			return err
+		}
+	}
+	if amountMismatch {
+		return fmt.Errorf("transaction amount mismatch")
+	}
+	return fmt.Errorf("matching aptos transfer to order address not found")
+}
+
+func aptosGet(path string) (body []byte, err error) {
+	network := mdb.NetworkAptos
+	defer recordMoveRPCResult(network, &err)
+
+	tried := make([]uint64, 0, 3)
+	var lastErr error
+	for attempts := 0; attempts < 3; attempts++ {
+		node, resolveErr := resolveAptosRpcNode(tried...)
+		if resolveErr != nil {
+			if lastErr != nil {
+				return nil, lastErr
+			}
+			return nil, resolveErr
+		}
+		if len(tried) > 0 {
+			log.Sugar.Warnf("[APTOS] trying alternate RPC node path=%s node=%s", path, data.RpcNodeLogLabel(*node))
+		}
+
+		body, err = aptosGetWithNode(*node, path)
+		if err == nil {
+			data.RecordRpcNodeSuccess(node.ID)
+			return body, nil
+		}
+
+		lastErr = err
+		failures, cooling := data.RecordRpcNodeFailure(node.ID)
+		nodeLabel := data.RpcNodeLogLabel(*node)
+		if cooling {
+			log.Sugar.Warnf("[APTOS] RPC node reached fail threshold path=%s node=%s failures=%d/%d", path, nodeLabel, failures, data.RpcFailoverThreshold)
+		} else {
+			log.Sugar.Warnf("[APTOS] RPC node failed path=%s node=%s failures=%d/%d", path, nodeLabel, failures, data.RpcFailoverThreshold)
+		}
+		tried = append(tried, node.ID)
+	}
+	return nil, lastErr
+}
+
+func resolveAptosRpcNode(excludeIDs ...uint64) (*mdb.RpcNode, error) {
+	node, err := data.SelectGeneralRpcNode(mdb.NetworkAptos, mdb.RpcNodeTypeHttp, excludeIDs...)
+	if err != nil {
+		return nil, err
+	}
+	if node == nil || node.ID == 0 {
+		return nil, fmt.Errorf("no enabled %s %s RPC node configured in rpc_nodes", mdb.NetworkAptos, mdb.RpcNodeTypeHttp)
+	}
+	rpcURL := strings.TrimSpace(node.Url)
+	if rpcURL == "" {
+		return nil, fmt.Errorf("rpc_nodes id=%d has empty url", node.ID)
+	}
+	node.Url = rpcURL
+	return node, nil
+}
+
+func aptosGetWithNode(node mdb.RpcNode, path string) (body []byte, err error) {
+	endpoint, err := aptosJoinURL(node.Url, path)
+	if err != nil {
+		return nil, err
+	}
+	req, err := http.NewRequest(http.MethodGet, endpoint, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", "application/json")
+	resp, err := (&http.Client{Timeout: manualVerifyRequestTimeout}).Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, _ = io.ReadAll(resp.Body)
+	if resp.StatusCode >= http.StatusBadRequest {
+		return nil, fmt.Errorf("aptos rpc HTTP %d: %s", resp.StatusCode, string(body))
+	}
+	return body, nil
+}
+
+func aptosJoinURL(base, path string) (string, error) {
+	base = strings.TrimSpace(base)
+	if base == "" {
+		return "", fmt.Errorf("empty aptos rpc url")
+	}
+	if strings.TrimSpace(path) == "" {
+		return strings.TrimRight(base, "/"), nil
+	}
+	path = strings.TrimSpace(path)
+	trimmedBase := strings.TrimRight(base, "/")
+	lowerBase := strings.ToLower(trimmedBase)
+	if strings.HasSuffix(lowerBase, "/v1") && strings.HasPrefix(path, "/v1") {
+		path = strings.TrimPrefix(path, "/v1")
+		if path == "" {
+			path = "/"
+		}
+	}
+	return trimmedBase + path, nil
+}
+
+func EnsureAptosTransferConfirmed(version int64) error {
+	if version <= 0 {
+		return fmt.Errorf("aptos transaction version missing")
+	}
+	latest, err := AptosGetLedgerVersion()
+	if err != nil {
+		return fmt.Errorf("fetch aptos latest ledger version: %w", err)
+	}
+	return ensureAptosConfirmations(version, latest)
+}
+
+func ensureAptosTransferConfirmedWithNode(version int64, node mdb.RpcNode) error {
+	if version <= 0 {
+		return fmt.Errorf("aptos transaction version missing")
+	}
+	body, err := aptosGetWithNode(node, "/v1")
+	if err != nil {
+		return fmt.Errorf("fetch aptos latest ledger version: %w", err)
+	}
+	latest := gjson.GetBytes(body, "ledger_version").Int()
+	return ensureAptosConfirmations(version, latest)
+}
+
+func ensureAptosConfirmations(version, latest int64) error {
+	chain, err := data.GetChainByNetwork(mdb.NetworkAptos)
+	if err != nil {
+		return err
+	}
+	minConfirmations := int64(1)
+	if chain != nil && chain.MinConfirmations > 0 {
+		minConfirmations = int64(chain.MinConfirmations)
+	}
+	if latest-version+1 < minConfirmations {
+		return fmt.Errorf("aptos transaction confirmations insufficient")
+	}
+	return nil
+}

src/model/service/epay_return.go

@@ -0,0 +1,167 @@
+package service
+
+import (
+	"fmt"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/GMWalletApp/epusdt/config"
+	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	"github.com/GMWalletApp/epusdt/model/response"
+	"github.com/GMWalletApp/epusdt/util/constant"
+	"github.com/GMWalletApp/epusdt/util/sign"
+)
+
+type EPayReturnRedirect struct {
+	TargetURL          string
+	IsMerchantRedirect bool
+}
+
+func isEPayOrder(order *mdb.Orders) bool {
+	return order != nil && strings.EqualFold(order.PaymentType, mdb.PaymentTypeEpay)
+}
+
+func buildCheckoutCounterPath(tradeID string) string {
+	return "/pay/checkout-counter/" + tradeID
+}
+
+func buildAbsoluteAppURL(path string) string {
+	path = strings.TrimSpace(path)
+	if path == "" {
+		return ""
+	}
+	if !strings.HasPrefix(path, "/") {
+		path = "/" + path
+	}
+	base := strings.TrimRight(strings.TrimSpace(config.GetAppUri()), "/")
+	if base == "" {
+		return path
+	}
+	return base + path
+}
+
+func buildEPayReturnPath(tradeID string) string {
+	return "/pay/return/" + tradeID
+}
+
+func buildPublicRedirectURL(order *mdb.Orders) string {
+	if order == nil {
+		return ""
+	}
+	raw := strings.TrimSpace(order.RedirectUrl)
+	if raw == "" || !isEPayOrder(order) {
+		return raw
+	}
+	return buildAbsoluteAppURL(buildEPayReturnPath(order.TradeId))
+}
+
+func ResolveOrderApiKey(order *mdb.Orders) (*mdb.ApiKey, error) {
+	if order == nil || order.ApiKeyID == 0 {
+		return nil, constant.OrderApiKeyUnavailableErr
+	}
+	row, err := data.GetApiKeyByID(order.ApiKeyID)
+	if err != nil {
+		return nil, err
+	}
+	if row == nil || row.ID == 0 || row.Status != mdb.ApiKeyStatusEnable {
+		return nil, constant.OrderApiKeyUnavailableErr
+	}
+	return row, nil
+}
+
+func BuildEPayResultParams(order *mdb.Orders, apiKeyRow *mdb.ApiKey) (map[string]string, error) {
+	if order == nil || apiKeyRow == nil {
+		return nil, constant.EPayReturnSignatureErr
+	}
+
+	pidInt, err := strconv.Atoi(strings.TrimSpace(apiKeyRow.Pid))
+	if err != nil {
+		return nil, constant.EPayReturnSignatureErr
+	}
+
+	notifyData := response.OrderNotifyResponseEpay{
+		PID:         pidInt,
+		TradeNo:     order.TradeId,
+		OutTradeNo:  order.OrderId,
+		Type:        "alipay",
+		Name:        order.Name,
+		Money:       fmt.Sprintf("%.4f", order.Amount),
+		TradeStatus: "TRADE_SUCCESS",
+	}
+
+	signstr, err := sign.Get(notifyData, apiKeyRow.SecretKey)
+	if err != nil {
+		return nil, constant.EPayReturnSignatureErr
+	}
+
+	return map[string]string{
+		"pid":          strconv.Itoa(pidInt),
+		"trade_no":     notifyData.TradeNo,
+		"out_trade_no": notifyData.OutTradeNo,
+		"type":         notifyData.Type,
+		"name":         notifyData.Name,
+		"money":        notifyData.Money,
+		"trade_status": notifyData.TradeStatus,
+		"sign":         signstr,
+		"sign_type":    "MD5",
+	}, nil
+}
+
+func appendQueryParams(rawURL string, params map[string]string) (string, error) {
+	rawURL = strings.TrimSpace(rawURL)
+	if rawURL == "" {
+		return "", constant.OrderRedirectURLErr
+	}
+
+	targetURL, err := url.Parse(rawURL)
+	if err != nil {
+		return "", constant.OrderRedirectURLErr
+	}
+
+	query := targetURL.Query()
+	for key, value := range params {
+		query.Set(key, value)
+	}
+	targetURL.RawQuery = query.Encode()
+	return targetURL.String(), nil
+}
+
+func ResolveEPayReturnRedirect(tradeID string) (*EPayReturnRedirect, error) {
+	order, err := GetOrderInfoByTradeId(tradeID)
+	if err != nil {
+		return nil, err
+	}
+
+	if !isEPayOrder(order) || order.Status != mdb.StatusPaySuccess {
+		return &EPayReturnRedirect{
+			TargetURL: buildCheckoutCounterPath(order.TradeId),
+		}, nil
+	}
+
+	rawMerchantURL := strings.TrimSpace(order.RedirectUrl)
+	if rawMerchantURL == "" {
+		return nil, constant.OrderRedirectURLErr
+	}
+
+	apiKeyRow, err := ResolveOrderApiKey(order)
+	if err != nil {
+		return nil, err
+	}
+
+	params, err := BuildEPayResultParams(order, apiKeyRow)
+	if err != nil {
+		return nil, err
+	}
+
+	targetURL, err := appendQueryParams(rawMerchantURL, params)
+	if err != nil {
+		return nil, err
+	}
+
+	return &EPayReturnRedirect{
+		TargetURL:          targetURL,
+		IsMerchantRedirect: true,
+	}, nil
+}

src/model/service/epay_return_test.go

@@ -0,0 +1,155 @@
+package service
+
+import (
+	"net/url"
+	"testing"
+
+	"github.com/GMWalletApp/epusdt/config"
+	"github.com/GMWalletApp/epusdt/internal/testutil"
+	"github.com/GMWalletApp/epusdt/model/dao"
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	"github.com/GMWalletApp/epusdt/util/constant"
+	"github.com/GMWalletApp/epusdt/util/sign"
+)
+
+func TestBuildPublicRedirectURLRewritesOnlyEpayOrders(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	epayOrder := &mdb.Orders{
+		TradeId:     "trade_epay_redirect",
+		PaymentType: mdb.PaymentTypeEpay,
+		RedirectUrl: "https://merchant.example/return",
+	}
+	wantRedirect := config.GetAppUri() + "/pay/return/trade_epay_redirect"
+	if got := buildPublicRedirectURL(epayOrder); got != wantRedirect {
+		t.Fatalf("epay redirect_url = %q, want internal return route", got)
+	}
+
+	gmpayOrder := &mdb.Orders{
+		TradeId:     "trade_gmpay_redirect",
+		PaymentType: mdb.PaymentTypeGmpay,
+		RedirectUrl: "https://merchant.example/return",
+	}
+	if got := buildPublicRedirectURL(gmpayOrder); got != "https://merchant.example/return" {
+		t.Fatalf("gmpay redirect_url = %q, want merchant raw redirect_url", got)
+	}
+
+	if got := buildPublicRedirectURL(&mdb.Orders{TradeId: "trade_empty", PaymentType: mdb.PaymentTypeEpay}); got != "" {
+		t.Fatalf("empty redirect_url = %q, want empty", got)
+	}
+}
+
+func TestBuildEPayResultParamsMatchesLegacyFields(t *testing.T) {
+	params, err := BuildEPayResultParams(&mdb.Orders{
+		TradeId: "trade_epay_params",
+		OrderId: "order_epay_params",
+		Name:    "VIP",
+		Amount:  1,
+	}, &mdb.ApiKey{
+		Pid:       "1001",
+		SecretKey: "epay-secret",
+	})
+	if err != nil {
+		t.Fatalf("BuildEPayResultParams(): %v", err)
+	}
+
+	expected := map[string]string{
+		"pid":          "1001",
+		"trade_no":     "trade_epay_params",
+		"out_trade_no": "order_epay_params",
+		"type":         "alipay",
+		"name":         "VIP",
+		"money":        "1.0000",
+		"trade_status": "TRADE_SUCCESS",
+		"sign_type":    "MD5",
+	}
+	for key, want := range expected {
+		if got := params[key]; got != want {
+			t.Fatalf("%s = %q, want %q", key, got, want)
+		}
+	}
+
+	signParams := map[string]interface{}{
+		"pid":          params["pid"],
+		"trade_no":     params["trade_no"],
+		"out_trade_no": params["out_trade_no"],
+		"type":         params["type"],
+		"name":         params["name"],
+		"money":        params["money"],
+		"trade_status": params["trade_status"],
+	}
+	wantSign, err := sign.Get(signParams, "epay-secret")
+	if err != nil {
+		t.Fatalf("sign.Get(): %v", err)
+	}
+	if got := params["sign"]; got != wantSign {
+		t.Fatalf("sign = %q, want %q", got, wantSign)
+	}
+}
+
+func TestBuildEPayResultParamsRejectsNonNumericPid(t *testing.T) {
+	_, err := BuildEPayResultParams(&mdb.Orders{
+		TradeId: "trade_bad_pid",
+		OrderId: "order_bad_pid",
+		Name:    "VIP",
+		Amount:  1,
+	}, &mdb.ApiKey{
+		Pid:       "not-a-number",
+		SecretKey: "epay-secret",
+	})
+	if err != constant.EPayReturnSignatureErr {
+		t.Fatalf("error = %v, want %v", err, constant.EPayReturnSignatureErr)
+	}
+}
+
+func TestResolveOrderApiKeyRejectsUnavailableRows(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if _, err := ResolveOrderApiKey(&mdb.Orders{TradeId: "missing_api_key_id"}); err != constant.OrderApiKeyUnavailableErr {
+		t.Fatalf("missing api_key_id error = %v, want %v", err, constant.OrderApiKeyUnavailableErr)
+	}
+
+	row := &mdb.ApiKey{
+		Name:      "disabled",
+		Pid:       "1201",
+		SecretKey: "disabled-secret",
+		Status:    mdb.ApiKeyStatusDisable,
+	}
+	if err := dao.Mdb.Create(row).Error; err != nil {
+		t.Fatalf("create disabled api key: %v", err)
+	}
+	if _, err := ResolveOrderApiKey(&mdb.Orders{TradeId: "disabled_api_key", ApiKeyID: row.ID}); err != constant.OrderApiKeyUnavailableErr {
+		t.Fatalf("disabled api key error = %v, want %v", err, constant.OrderApiKeyUnavailableErr)
+	}
+}
+
+func TestAppendQueryParamsPreservesMerchantQuery(t *testing.T) {
+	target, err := appendQueryParams("https://merchant.example/return?from=merchant", map[string]string{
+		"pid":          "1001",
+		"trade_no":     "trade_epay_redirect",
+		"trade_status": "TRADE_SUCCESS",
+	})
+	if err != nil {
+		t.Fatalf("appendQueryParams(): %v", err)
+	}
+
+	parsed, err := url.Parse(target)
+	if err != nil {
+		t.Fatalf("url.Parse(): %v", err)
+	}
+	query := parsed.Query()
+	if got := query.Get("from"); got != "merchant" {
+		t.Fatalf("from = %q, want merchant", got)
+	}
+	if got := query.Get("pid"); got != "1001" {
+		t.Fatalf("pid = %q, want 1001", got)
+	}
+	if got := query.Get("trade_no"); got != "trade_epay_redirect" {
+		t.Fatalf("trade_no = %q, want trade_epay_redirect", got)
+	}
+	if got := query.Get("trade_status"); got != "TRADE_SUCCESS" {
+		t.Fatalf("trade_status = %q, want TRADE_SUCCESS", got)
+	}
+}

src/model/service/manual_payment_verify.go

@@ -16,6 +16,7 @@ import (
 	tron "github.com/GMWalletApp/epusdt/crypto"
 	"github.com/GMWalletApp/epusdt/model/data"
 	"github.com/GMWalletApp/epusdt/model/mdb"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
 	"github.com/GMWalletApp/epusdt/util/constant"
 	"github.com/GMWalletApp/epusdt/util/math"
 	"github.com/ethereum/go-ethereum/common"
@@ -23,6 +24,10 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/shopspring/decimal"
 	"github.com/tidwall/gjson"
+	"github.com/xssnick/tonutils-go/address"
+	"github.com/xssnick/tonutils-go/tlb"
+	"github.com/xssnick/tonutils-go/ton"
+	"github.com/xssnick/tonutils-go/ton/jetton"
 )
 
 const manualVerifyRequestTimeout = 15 * time.Second
@@ -82,6 +87,10 @@ func validateManualOrderPaymentDefault(order *mdb.Orders, blockTransactionID str
 		canonicalTxID, err = validateManualTronPayment(order, txID)
 	case mdb.NetworkSolana:
 		canonicalTxID, err = validateManualSolanaPayment(order, txID)
+	case mdb.NetworkTon:
+		canonicalTxID, err = validateManualTonPayment(order, txID)
+	case mdb.NetworkAptos:
+		canonicalTxID, err = ValidateManualAptosPayment(order, txID)
 	case mdb.NetworkEthereum, mdb.NetworkBsc, mdb.NetworkPolygon, mdb.NetworkPlasma:
 		canonicalTxID, err = validateManualEvmPayment(order, txID)
 	default:
@@ -116,7 +125,7 @@ func ensureManualBlockTransactionUnused(order *mdb.Orders, canonicalTxID string)
 
 func manualBlockTransactionIDIsHex(network string) bool {
 	switch strings.ToLower(strings.TrimSpace(network)) {
-	case mdb.NetworkTron, mdb.NetworkEthereum, mdb.NetworkBsc, mdb.NetworkPolygon, mdb.NetworkPlasma:
+	case mdb.NetworkTron, mdb.NetworkEthereum, mdb.NetworkBsc, mdb.NetworkPolygon, mdb.NetworkPlasma, mdb.NetworkAptos:
 		return true
 	default:
 		return false
@@ -142,7 +151,7 @@ func equivalentManualBlockTransactionIDs(network, canonicalTxID string) []string
 
 	add(canonicalTxID)
 	switch network {
-	case mdb.NetworkEthereum, mdb.NetworkBsc, mdb.NetworkPolygon, mdb.NetworkPlasma:
+	case mdb.NetworkEthereum, mdb.NetworkBsc, mdb.NetworkPolygon, mdb.NetworkPlasma, mdb.NetworkAptos:
 		body := strings.TrimPrefix(strings.TrimPrefix(canonicalTxID, "0x"), "0X")
 		body = strings.ToLower(body)
 		add("0x" + body)
@@ -636,6 +645,245 @@ func tronPostJSON(baseURL, apiKey, path string, body interface{}, out interface{
 	return json.Unmarshal(raw, out)
 }
 
+type manualTonTxRef struct {
+	ReceiveRaw string
+	LT         uint64
+	HashHex    string
+	HasLT      bool
+}
+
+func validateManualTonPayment(order *mdb.Orders, txID string) (string, error) {
+	ref, err := parseManualTonTxRef(txID)
+	if err != nil {
+		return "", err
+	}
+	orderAddr, err := addressutil.ParseTonMainnetAddress(order.ReceiveAddress)
+	if err != nil {
+		return "", fmt.Errorf("invalid order receive address: %w", err)
+	}
+	if ref.ReceiveRaw != "" && ref.ReceiveRaw != orderAddr.Raw {
+		return "", fmt.Errorf("transaction recipient mismatch")
+	}
+
+	nodes, err := data.ListManualPaymentRpcCandidates(mdb.NetworkTon, mdb.RpcNodeTypeLite)
+	if err != nil {
+		return "", err
+	}
+	if len(nodes) == 0 {
+		return "", fmt.Errorf("no enabled %s %s RPC node configured in rpc_nodes", mdb.NetworkTon, mdb.RpcNodeTypeLite)
+	}
+
+	var verifyErrors []string
+	for _, node := range nodes {
+		api, closeFn, err := dialManualTonClient(node)
+		if err != nil {
+			verifyErrors = append(verifyErrors, fmt.Sprintf("%s: connect: %v", manualRpcNodeLabel(node), err))
+			continue
+		}
+		canonicalID, err := validateManualTonPaymentWithAPI(context.Background(), api, order, orderAddr.Address, ref)
+		closeFn()
+		if err != nil {
+			verifyErrors = append(verifyErrors, fmt.Sprintf("%s: %v", manualRpcNodeLabel(node), err))
+			continue
+		}
+		return canonicalID, nil
+	}
+	if len(verifyErrors) > 0 {
+		return "", fmt.Errorf("manual TON verification failed: %s", strings.Join(verifyErrors, "; "))
+	}
+	return "", fmt.Errorf("no enabled %s %s RPC node configured in rpc_nodes", mdb.NetworkTon, mdb.RpcNodeTypeLite)
+}
+
+func parseManualTonTxRef(input string) (manualTonTxRef, error) {
+	raw := strings.TrimSpace(input)
+	if raw == "" {
+		return manualTonTxRef{}, fmt.Errorf("block_transaction_id is required")
+	}
+	if strings.HasPrefix(strings.ToLower(raw), "ton:") {
+		body := raw[4:]
+		last := strings.LastIndex(body, ":")
+		if last <= 0 || last == len(body)-1 {
+			return manualTonTxRef{}, fmt.Errorf("invalid ton canonical transaction id")
+		}
+		hashHex, err := normalizeTonTxHashHex(body[last+1:])
+		if err != nil {
+			return manualTonTxRef{}, err
+		}
+		left := body[:last]
+		mid := strings.LastIndex(left, ":")
+		if mid <= 0 || mid == len(left)-1 {
+			return manualTonTxRef{}, fmt.Errorf("invalid ton canonical transaction id")
+		}
+		lt, err := parseUint64Strict(left[mid+1:])
+		if err != nil {
+			return manualTonTxRef{}, fmt.Errorf("invalid ton transaction lt")
+		}
+		receiveRaw, err := addressutil.TonRawAddressKey(left[:mid])
+		if err != nil {
+			return manualTonTxRef{}, fmt.Errorf("invalid ton canonical recipient: %w", err)
+		}
+		return manualTonTxRef{ReceiveRaw: receiveRaw, LT: lt, HashHex: hashHex, HasLT: true}, nil
+	}
+	if idx := strings.Index(raw, ":"); idx > 0 {
+		lt, err := parseUint64Strict(raw[:idx])
+		if err != nil {
+			return manualTonTxRef{}, fmt.Errorf("invalid ton transaction lt")
+		}
+		hashHex, err := normalizeTonTxHashHex(raw[idx+1:])
+		if err != nil {
+			return manualTonTxRef{}, err
+		}
+		return manualTonTxRef{LT: lt, HashHex: hashHex, HasLT: true}, nil
+	}
+	hashHex, err := normalizeTonTxHashHex(raw)
+	if err != nil {
+		return manualTonTxRef{}, err
+	}
+	return manualTonTxRef{HashHex: hashHex}, nil
+}
+
+func normalizeTonTxHashHex(raw string) (string, error) {
+	hashHex := strings.ToLower(strings.TrimSpace(strings.TrimPrefix(strings.TrimPrefix(raw, "0x"), "0X")))
+	if len(hashHex) != 64 {
+		return "", fmt.Errorf("invalid ton transaction hash length")
+	}
+	if _, err := hex.DecodeString(hashHex); err != nil {
+		return "", fmt.Errorf("invalid ton transaction hash")
+	}
+	return hashHex, nil
+}
+
+func parseUint64Strict(raw string) (uint64, error) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return 0, fmt.Errorf("empty integer")
+	}
+	var out uint64
+	for _, ch := range raw {
+		if ch < '0' || ch > '9' {
+			return 0, fmt.Errorf("invalid integer")
+		}
+		out = out*10 + uint64(ch-'0')
+	}
+	return out, nil
+}
+
+func dialManualTonClient(node mdb.RpcNode) (ton.APIClientWrapped, func(), error) {
+	ctx, cancel := context.WithTimeout(context.Background(), manualVerifyRequestTimeout)
+	defer cancel()
+	return ConnectTonLiteAPI(ctx, node.Url, manualVerifyRequestTimeout, 3)
+}
+
+func validateManualTonPaymentWithAPI(ctx context.Context, api ton.APIClientWrapped, order *mdb.Orders, receive *address.Address, ref manualTonTxRef) (string, error) {
+	master, err := api.CurrentMasterchainInfo(ctx)
+	if err != nil {
+		return "", fmt.Errorf("fetch current masterchain: %w", err)
+	}
+	txs, err := listManualTonCandidateTransactions(ctx, api, master, receive, ref)
+	if err != nil {
+		return "", fmt.Errorf("list ton account transactions: %w", err)
+	}
+	if len(txs) == 0 {
+		return "", fmt.Errorf("transaction not found")
+	}
+
+	state, err := manualTonTokenState(ctx, api, master, receive)
+	if err != nil {
+		return "", err
+	}
+	return validateManualTonPaymentCandidates(order, receive, ref, txs, state)
+}
+
+func validateManualTonPaymentCandidates(order *mdb.Orders, receive *address.Address, ref manualTonTxRef, txs []*tlb.Transaction, state *manualTonState) (string, error) {
+	if state == nil {
+		state = &manualTonState{jettonWallets: make(map[string]mdb.ChainToken)}
+	}
+	var matched []*TonObservedTransfer
+	for _, tx := range txs {
+		if tx == nil {
+			continue
+		}
+		hashHex := hex.EncodeToString(tx.Hash)
+		if !strings.EqualFold(hashHex, ref.HashHex) {
+			continue
+		}
+		if ref.HasLT && tx.LT != ref.LT {
+			continue
+		}
+		transfer, err := ParseTonInboundTransfer(tx, receive, state.nativeToken, state.jettonWallets)
+		if err != nil || transfer == nil {
+			continue
+		}
+		if err = EnsureTonTransferMatchesOrder(order, transfer); err != nil {
+			return "", err
+		}
+		matched = append(matched, transfer)
+	}
+	if len(matched) == 0 {
+		return "", fmt.Errorf("matching ton transfer to order address not found")
+	}
+	if len(matched) > 1 && !ref.HasLT {
+		return "", fmt.Errorf("ton transaction hash matched multiple recent transactions; submit canonical id or lt:hash")
+	}
+	receiveRaw := addressutil.TonRawAddressObjectKey(receive)
+	return TonCanonicalBlockTransactionID(receiveRaw, matched[0].LT, matched[0].TxHashHex), nil
+}
+
+func listManualTonCandidateTransactions(ctx context.Context, api ton.APIClientWrapped, master *ton.BlockIDExt, receive *address.Address, ref manualTonTxRef) ([]*tlb.Transaction, error) {
+	waiter := api.WaitForBlock(master.SeqNo)
+	if ref.HasLT {
+		hashBytes, err := hex.DecodeString(ref.HashHex)
+		if err != nil {
+			return nil, err
+		}
+		return waiter.ListTransactions(ctx, receive, 1, ref.LT, hashBytes)
+	}
+
+	account, err := waiter.GetAccount(ctx, master, receive)
+	if err != nil {
+		return nil, fmt.Errorf("fetch ton account state: %w", err)
+	}
+	if account == nil || account.LastTxLT == 0 || len(account.LastTxHash) == 0 {
+		return nil, fmt.Errorf("transaction not found")
+	}
+	return waiter.ListTransactions(ctx, receive, 100, account.LastTxLT, account.LastTxHash)
+}
+
+type manualTonState struct {
+	nativeToken   *mdb.ChainToken
+	jettonWallets map[string]mdb.ChainToken
+}
+
+func manualTonTokenState(ctx context.Context, api ton.APIClientWrapped, master *ton.BlockIDExt, receive *address.Address) (*manualTonState, error) {
+	tokens, err := data.ListEnabledChainTokensByNetwork(mdb.NetworkTon)
+	if err != nil {
+		return nil, err
+	}
+	state := &manualTonState{jettonWallets: make(map[string]mdb.ChainToken)}
+	for i := range tokens {
+		sym := strings.ToUpper(strings.TrimSpace(tokens[i].Symbol))
+		contract := strings.TrimSpace(tokens[i].ContractAddress)
+		if sym == TonNativeSymbol && contract == "" {
+			token := tokens[i]
+			state.nativeToken = &token
+			continue
+		}
+		if contract == "" {
+			continue
+		}
+		masterAddr, err := addressutil.ParseTonMainnetAddress(contract)
+		if err != nil {
+			continue
+		}
+		wallet, err := jetton.NewJettonMasterClient(api, masterAddr.Address).GetJettonWalletAtBlock(ctx, receive, master)
+		if err != nil {
+			continue
+		}
+		state.jettonWallets[addressutil.TonRawAddressObjectKey(wallet.Address())] = tokens[i]
+	}
+	return state, nil
+}
+
 func validateManualSolanaPayment(order *mdb.Orders, sig string) (string, error) {
 	sig = strings.TrimSpace(sig)
 	nodes, err := data.ListManualPaymentRpcCandidates(mdb.NetworkSolana, mdb.RpcNodeTypeHttp)

src/model/service/manual_payment_verify_test.go

@@ -1,7 +1,9 @@
 package service
 
 import (
+	"bytes"
 	"context"
+	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -16,11 +18,33 @@ import (
 	"github.com/GMWalletApp/epusdt/internal/testutil"
 	"github.com/GMWalletApp/epusdt/model/dao"
 	"github.com/GMWalletApp/epusdt/model/mdb"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
 	"github.com/dromara/carbon/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/xssnick/tonutils-go/address"
+	"github.com/xssnick/tonutils-go/tlb"
+	"github.com/xssnick/tonutils-go/ton"
+	"github.com/xssnick/tonutils-go/ton/jetton"
+	"github.com/xssnick/tonutils-go/tvm/cell"
+	"gorm.io/gorm/clause"
 )
 
+func upsertTestChainToken(t *testing.T, token mdb.ChainToken) {
+	t.Helper()
+	if err := dao.Mdb.Clauses(clause.OnConflict{
+		Columns: []clause.Column{{Name: "network"}, {Name: "symbol"}},
+		DoUpdates: clause.AssignmentColumns([]string{
+			"contract_address",
+			"decimals",
+			"enabled",
+			"min_amount",
+		}),
+	}).Create(&token).Error; err != nil {
+		t.Fatalf("upsert token: %v", err)
+	}
+}
+
 func TestManualVerifyEvmHashAcceptsOptional0x(t *testing.T) {
 	hash := strings.Repeat("a", 64)
 	if !isEvmHash(hash) {
@@ -89,6 +113,275 @@ func TestManualVerifyNormalizeTronTxIDAcceptsOptional0x(t *testing.T) {
 	}
 }
 
+func TestValidateManualAptosPayment(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := dao.Mdb.Create(&mdb.Chain{Network: mdb.NetworkAptos, Enabled: true, MinConfirmations: 1}).Error; err != nil {
+		t.Fatalf("create aptos chain: %v", err)
+	}
+	usdc := "0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b"
+	if err := dao.Mdb.Create(&mdb.ChainToken{
+		Network:         mdb.NetworkAptos,
+		Symbol:          "USDC",
+		ContractAddress: usdc,
+		Decimals:        6,
+		Enabled:         true,
+	}).Error; err != nil {
+		t.Fatalf("create aptos usdc token: %v", err)
+	}
+
+	receive, err := addressutil.NormalizeMoveAddress("0xa")
+	if err != nil {
+		t.Fatalf("normalize aptos receive: %v", err)
+	}
+	store, err := addressutil.NormalizeMoveAddress("0x11")
+	if err != nil {
+		t.Fatalf("normalize aptos store: %v", err)
+	}
+	senderStore, err := addressutil.NormalizeMoveAddress("0x12")
+	if err != nil {
+		t.Fatalf("normalize aptos sender store: %v", err)
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		switch {
+		case strings.HasPrefix(r.URL.Path, "/v1/transactions/by_hash/"):
+			_, _ = w.Write([]byte(`{"type":"user_transaction","success":true,"hash":"0xabc","version":"101","timestamp":"1700000000123456","payload":{"function":"0x1::primary_fungible_store::transfer","arguments":[{"inner":"` + usdc + `"},"` + receive + `","4200000"],"type":"entry_function_payload"},"events":[{"type":"0x1::fungible_asset::Withdraw","data":{"amount":"4200000","store":"` + senderStore + `"}},{"type":"0x1::fungible_asset::Deposit","data":{"amount":"4200000","store":"` + store + `"}}],"changes":[{"address":"` + senderStore + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdc + `"}}},"type":"write_resource"},{"address":"` + store + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdc + `"}}},"type":"write_resource"},{"address":"` + store + `","data":{"type":"0x1::object::ObjectCore","data":{"owner":"` + receive + `"}},"type":"write_resource"}]}`))
+		case r.URL.Path == "/v1":
+			_, _ = w.Write([]byte(`{"ledger_version":"101"}`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer server.Close()
+	seedTestAptosRPCNode(t, server.URL, mdb.RpcNodePurposeGeneral, mdb.RpcNodeStatusOk, 100)
+
+	order := &mdb.Orders{
+		BaseModel:      mdb.BaseModel{ID: 1, CreatedAt: *carbon.NewTime(carbon.CreateFromTimestampMilli(1699999999000))},
+		Network:        mdb.NetworkAptos,
+		Token:          "USDC",
+		ActualAmount:   4.2,
+		ReceiveAddress: receive,
+	}
+	got, err := ValidateManualAptosPayment(order, "ABC")
+	if err != nil {
+		t.Fatalf("ValidateManualAptosPayment(): %v", err)
+	}
+	if got != "0xabc" {
+		t.Fatalf("canonical tx id = %q, want %q", got, "0xabc")
+	}
+}
+
+func TestParseManualTonTxRefAcceptsCanonicalLTAndHashOnly(t *testing.T) {
+	receiveRaw := "0:ba295e33b3c4c9b5265aa4ead1166a92931ce9abea120a8c5e91044a1257f89c"
+	hash := strings.Repeat("a", 64)
+
+	ref, err := parseManualTonTxRef("ton:" + receiveRaw + ":123:" + strings.ToUpper(hash))
+	if err != nil {
+		t.Fatalf("parse canonical TON tx ref: %v", err)
+	}
+	if ref.ReceiveRaw != receiveRaw || ref.LT != 123 || ref.HashHex != hash || !ref.HasLT {
+		t.Fatalf("canonical ref = %#v", ref)
+	}
+
+	ref, err = parseManualTonTxRef("456:0X" + strings.ToUpper(hash))
+	if err != nil {
+		t.Fatalf("parse lt:hash TON tx ref: %v", err)
+	}
+	if ref.ReceiveRaw != "" || ref.LT != 456 || ref.HashHex != hash || !ref.HasLT {
+		t.Fatalf("lt:hash ref = %#v", ref)
+	}
+
+	ref, err = parseManualTonTxRef("0X" + strings.ToUpper(hash))
+	if err != nil {
+		t.Fatalf("parse hash-only TON tx ref: %v", err)
+	}
+	if ref.ReceiveRaw != "" || ref.LT != 0 || ref.HashHex != hash || ref.HasLT {
+		t.Fatalf("hash-only ref = %#v", ref)
+	}
+}
+
+type fakeManualTonAPI struct {
+	ton.APIClientWrapped
+	master          *ton.BlockIDExt
+	account         *tlb.Account
+	txs             []*tlb.Transaction
+	getAccountCalls int
+	listCalls       []manualTonListCall
+}
+
+type manualTonListCall struct {
+	limit   uint32
+	lt      uint64
+	hashHex string
+}
+
+func (f *fakeManualTonAPI) CurrentMasterchainInfo(context.Context) (*ton.BlockIDExt, error) {
+	return f.master, nil
+}
+
+func (f *fakeManualTonAPI) WaitForBlock(uint32) ton.APIClientWrapped {
+	return f
+}
+
+func (f *fakeManualTonAPI) GetAccount(context.Context, *ton.BlockIDExt, *address.Address) (*tlb.Account, error) {
+	f.getAccountCalls++
+	if f.account == nil {
+		return &tlb.Account{}, nil
+	}
+	return f.account, nil
+}
+
+func (f *fakeManualTonAPI) ListTransactions(_ context.Context, _ *address.Address, limit uint32, lt uint64, txHash []byte) ([]*tlb.Transaction, error) {
+	f.listCalls = append(f.listCalls, manualTonListCall{
+		limit:   limit,
+		lt:      lt,
+		hashHex: hex.EncodeToString(txHash),
+	})
+	return f.txs, nil
+}
+
+func TestValidateManualTonPaymentWithAPINativeTON(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := dao.Mdb.Model(&mdb.ChainToken{}).
+		Where("network = ? AND symbol = ?", mdb.NetworkTon, "USDT").
+		Update("enabled", false).Error; err != nil {
+		t.Fatalf("disable TON USDT token: %v", err)
+	}
+
+	receive := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	sender := address.NewAddress(0, 0, bytes.Repeat([]byte{0x66}, 32)).Bounce(false).Testnet(false)
+	tx := tonTestInboundTx(t, sender, receive, tlb.MustFromTON("1.23"), nil)
+	order := &mdb.Orders{
+		BaseModel:      mdb.BaseModel{ID: 1, CreatedAt: *carbon.NewTime(carbon.CreateFromTimestampMilli(time.Now().Add(-time.Minute).UnixMilli()))},
+		Network:        mdb.NetworkTon,
+		Token:          "TON",
+		ActualAmount:   1.23,
+		ReceiveAddress: receive.Bounce(false).String(),
+	}
+	api := &fakeManualTonAPI{
+		master: &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: -0x8000000000000000, SeqNo: 9},
+		txs:    []*tlb.Transaction{tx},
+	}
+	ref := manualTonTxRef{LT: tx.LT, HashHex: hex.EncodeToString(tx.Hash), HasLT: true}
+
+	got, err := validateManualTonPaymentWithAPI(context.Background(), api, order, receive, ref)
+	if err != nil {
+		t.Fatalf("validateManualTonPaymentWithAPI(): %v", err)
+	}
+	if api.getAccountCalls != 0 {
+		t.Fatalf("exact TON ref fetched account state %d times, want 0", api.getAccountCalls)
+	}
+	if len(api.listCalls) != 1 {
+		t.Fatalf("ListTransactions calls = %#v, want one exact lookup", api.listCalls)
+	}
+	if call := api.listCalls[0]; call.limit != 1 || call.lt != tx.LT || call.hashHex != hex.EncodeToString(tx.Hash) {
+		t.Fatalf("ListTransactions exact call = %#v, want limit=1 lt/hash from ref", call)
+	}
+	want := TonCanonicalBlockTransactionID(receive.StringRaw(), tx.LT, hex.EncodeToString(tx.Hash))
+	if got != want {
+		t.Fatalf("canonical id = %q, want %q", got, want)
+	}
+}
+
+func TestValidateManualTonPaymentCandidatesUSDTJetton(t *testing.T) {
+	receive := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	sender := address.NewAddress(0, 0, bytes.Repeat([]byte{0x68}, 32)).Bounce(false).Testnet(false)
+	jettonWallet := address.NewAddress(0, 0, bytes.Repeat([]byte{0x69}, 32)).Bounce(false).Testnet(false)
+	body, err := tlb.ToCell(jetton.TransferNotification{
+		QueryID:        7,
+		Amount:         tlb.MustFromNano(big.NewInt(1_000_000), 6),
+		Sender:         sender,
+		ForwardPayload: cell.BeginCell().EndCell(),
+	})
+	if err != nil {
+		t.Fatalf("build jetton notification body: %v", err)
+	}
+	tx := tonTestInboundTx(t, jettonWallet, receive, tlb.FromNanoTONU(1), body)
+	order := &mdb.Orders{
+		BaseModel:      mdb.BaseModel{ID: 1, CreatedAt: *carbon.NewTime(carbon.CreateFromTimestampMilli(time.Now().Add(-time.Minute).UnixMilli()))},
+		Network:        mdb.NetworkTon,
+		Token:          "USDT",
+		ActualAmount:   1,
+		ReceiveAddress: receive.Bounce(false).String(),
+	}
+	state := &manualTonState{
+		jettonWallets: map[string]mdb.ChainToken{
+			addressutil.TonRawAddressObjectKey(jettonWallet): {
+				BaseModel: mdb.BaseModel{ID: 2},
+				Network:   mdb.NetworkTon,
+				Symbol:    "USDT",
+				Decimals:  6,
+				Enabled:   true,
+			},
+		},
+	}
+
+	got, err := validateManualTonPaymentCandidates(order, receive, manualTonTxRef{
+		LT:      tx.LT,
+		HashHex: hex.EncodeToString(tx.Hash),
+		HasLT:   true,
+	}, []*tlb.Transaction{tx}, state)
+	if err != nil {
+		t.Fatalf("validateManualTonPaymentCandidates(): %v", err)
+	}
+	want := TonCanonicalBlockTransactionID(receive.StringRaw(), tx.LT, hex.EncodeToString(tx.Hash))
+	if got != want {
+		t.Fatalf("canonical id = %q, want %q", got, want)
+	}
+}
+
+func TestValidateManualTonPaymentWithAPIRejectsAmbiguousHashOnly(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := dao.Mdb.Model(&mdb.ChainToken{}).
+		Where("network = ? AND symbol = ?", mdb.NetworkTon, "USDT").
+		Update("enabled", false).Error; err != nil {
+		t.Fatalf("disable TON USDT token: %v", err)
+	}
+
+	receive := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	sender := address.NewAddress(0, 0, bytes.Repeat([]byte{0x67}, 32)).Bounce(false).Testnet(false)
+	tx1 := tonTestInboundTx(t, sender, receive, tlb.MustFromTON("1.23"), nil)
+	tx2 := tonTestInboundTx(t, sender, receive, tlb.MustFromTON("1.23"), nil)
+	tx2.LT = tx1.LT + 1
+	order := &mdb.Orders{
+		BaseModel:      mdb.BaseModel{ID: 1, CreatedAt: *carbon.NewTime(carbon.CreateFromTimestampMilli(time.Now().Add(-time.Minute).UnixMilli()))},
+		Network:        mdb.NetworkTon,
+		Token:          "TON",
+		ActualAmount:   1.23,
+		ReceiveAddress: receive.Bounce(false).String(),
+	}
+	api := &fakeManualTonAPI{
+		master: &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: -0x8000000000000000, SeqNo: 9},
+		account: &tlb.Account{
+			LastTxLT:   tx2.LT,
+			LastTxHash: tx2.Hash,
+		},
+		txs: []*tlb.Transaction{tx1, tx2},
+	}
+
+	_, err := validateManualTonPaymentWithAPI(context.Background(), api, order, receive, manualTonTxRef{
+		HashHex: hex.EncodeToString(tx1.Hash),
+	})
+	if err == nil || !strings.Contains(err.Error(), "matched multiple") {
+		t.Fatalf("validate ambiguous hash-only error = %v, want multiple-match error", err)
+	}
+	if api.getAccountCalls != 1 {
+		t.Fatalf("hash-only TON ref fetched account state %d times, want 1", api.getAccountCalls)
+	}
+	if len(api.listCalls) != 1 {
+		t.Fatalf("ListTransactions calls = %#v, want one recent lookup", api.listCalls)
+	}
+	if call := api.listCalls[0]; call.limit != 100 || call.lt != tx2.LT || call.hashHex != hex.EncodeToString(tx2.Hash) {
+		t.Fatalf("ListTransactions recent call = %#v, want account last tx cursor", call)
+	}
+}
+
 func TestManualVerifyDialEvmClientsIncludesHTTPNode(t *testing.T) {
 	cleanup := testutil.SetupTestDatabases(t)
 	defer cleanup()
@@ -369,15 +662,13 @@ func TestManualVerifyTronTRC20UsesTransferEvent(t *testing.T) {
 	if err != nil {
 		t.Fatalf("recipient address: %v", err)
 	}
-	if err = dao.Mdb.Create(&mdb.ChainToken{
+	upsertTestChainToken(t, mdb.ChainToken{
 		Network:         mdb.NetworkTron,
 		Symbol:          "USDT",
 		ContractAddress: contractAddress,
 		Decimals:        6,
 		Enabled:         true,
-	}).Error; err != nil {
+	})
-		t.Fatalf("create token: %v", err)
-	}
 
 	rawAmount := big.NewInt(1230000)
 	tx := manualTronTransactionFromCallData(t, contractHex, recipientHex, rawAmount)
@@ -491,15 +782,13 @@ func TestManualVerifyTronPaymentHTTPFlow(t *testing.T) {
 	}).Error; err != nil {
 		t.Fatalf("create tron rpc node: %v", err)
 	}
-	if err = dao.Mdb.Create(&mdb.ChainToken{
+	upsertTestChainToken(t, mdb.ChainToken{
 		Network:         mdb.NetworkTron,
 		Symbol:          "USDT",
 		ContractAddress: contractAddress,
 		Decimals:        6,
 		Enabled:         true,
-	}).Error; err != nil {
+	})
-		t.Fatalf("create token: %v", err)
-	}
 	order := &mdb.Orders{
 		TradeId:        "manual-tron-http-flow",
 		OrderId:        "manual-tron-http-flow",

src/model/service/move_rpc_routing_test.go

@@ -0,0 +1,203 @@
+package service
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/GMWalletApp/epusdt/internal/testutil"
+	"github.com/GMWalletApp/epusdt/model/dao"
+	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
+	"github.com/dromara/carbon/v2"
+)
+
+func seedTestAptosRPCNode(t *testing.T, url, purpose, status string, weight int) mdb.RpcNode {
+	t.Helper()
+	node := mdb.RpcNode{
+		Network: mdb.NetworkAptos,
+		Url:     url,
+		Type:    mdb.RpcNodeTypeHttp,
+		Weight:  weight,
+		Enabled: true,
+		Purpose: purpose,
+		Status:  status,
+	}
+	if node.Purpose == "" {
+		node.Purpose = mdb.RpcNodePurposeGeneral
+	}
+	if node.Status == "" {
+		node.Status = mdb.RpcNodeStatusOk
+	}
+	if err := dao.Mdb.Create(&node).Error; err != nil {
+		t.Fatalf("seed aptos rpc_nodes: %v", err)
+	}
+	return node
+}
+
+func TestAptosGetLedgerVersionUsesRpcNodes(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	data.ResetRpcFailoverForTest()
+	t.Cleanup(data.ResetRpcFailoverForTest)
+
+	var disabledCalls int
+	disabled := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		disabledCalls++
+		_, _ = w.Write([]byte(`{"ledger_version":"999"}`))
+	}))
+	defer disabled.Close()
+	disabledNode := mdb.RpcNode{
+		Network: mdb.NetworkAptos,
+		Url:     disabled.URL,
+		Type:    mdb.RpcNodeTypeHttp,
+		Weight:  1000,
+		Enabled: false,
+		Purpose: mdb.RpcNodePurposeGeneral,
+		Status:  mdb.RpcNodeStatusOk,
+	}
+	if err := dao.Mdb.Create(&disabledNode).Error; err != nil {
+		t.Fatalf("seed disabled aptos rpc_nodes: %v", err)
+	}
+	if err := dao.Mdb.Model(&mdb.RpcNode{}).Where("id = ?", disabledNode.ID).Update("enabled", false).Error; err != nil {
+		t.Fatalf("disable aptos rpc_nodes: %v", err)
+	}
+
+	var calls int
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		calls++
+		if r.URL.Path != "/v1" {
+			http.NotFound(w, r)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"ledger_version":"123"}`))
+	}))
+	defer server.Close()
+	seedTestAptosRPCNode(t, server.URL, mdb.RpcNodePurposeGeneral, mdb.RpcNodeStatusOk, 100)
+
+	got, err := AptosGetLedgerVersion()
+	if err != nil {
+		t.Fatalf("AptosGetLedgerVersion(): %v", err)
+	}
+	if got != 123 {
+		t.Fatalf("ledger version = %d, want 123", got)
+	}
+	if calls != 1 {
+		t.Fatalf("rpc calls = %d, want 1", calls)
+	}
+	if disabledCalls != 0 {
+		t.Fatalf("disabled rpc calls = %d, want 0", disabledCalls)
+	}
+}
+
+func TestAptosGetTransactionsFallsBackToAlternateRpcNode(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	data.ResetRpcFailoverForTest()
+	t.Cleanup(data.ResetRpcFailoverForTest)
+
+	var primaryCalls int
+	primary := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		primaryCalls++
+		http.Error(w, "temporary failure", http.StatusBadGateway)
+	}))
+	defer primary.Close()
+	var backupCalls int
+	backup := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		backupCalls++
+		if r.URL.Path != "/v1/transactions" || r.URL.Query().Get("start") != "10" || r.URL.Query().Get("limit") != "2" {
+			http.NotFound(w, r)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`[]`))
+	}))
+	defer backup.Close()
+	seedTestAptosRPCNode(t, primary.URL, mdb.RpcNodePurposeGeneral, mdb.RpcNodeStatusOk, 100)
+	seedTestAptosRPCNode(t, backup.URL, mdb.RpcNodePurposeGeneral, mdb.RpcNodeStatusOk, 1)
+
+	body, err := AptosGetTransactions(10, 2)
+	if err != nil {
+		t.Fatalf("AptosGetTransactions(): %v", err)
+	}
+	if string(body) != "[]" {
+		t.Fatalf("transactions body = %s, want []", string(body))
+	}
+	if primaryCalls != 1 || backupCalls != 1 {
+		t.Fatalf("rpc calls primary=%d backup=%d, want 1/1", primaryCalls, backupCalls)
+	}
+}
+
+func TestValidateManualAptosPaymentUsesManualRpcFallback(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := dao.Mdb.Create(&mdb.Chain{Network: mdb.NetworkAptos, Enabled: true, MinConfirmations: 1}).Error; err != nil {
+		t.Fatalf("create aptos chain: %v", err)
+	}
+	const usdc = "0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b"
+	upsertTestChainToken(t, mdb.ChainToken{
+		Network:         mdb.NetworkAptos,
+		Symbol:          "USDC",
+		ContractAddress: usdc,
+		Decimals:        6,
+		Enabled:         true,
+	})
+
+	receive, err := addressutil.NormalizeMoveAddress("0xa")
+	if err != nil {
+		t.Fatalf("normalize aptos receive: %v", err)
+	}
+	store, err := addressutil.NormalizeMoveAddress("0x31")
+	if err != nil {
+		t.Fatalf("normalize aptos store: %v", err)
+	}
+	senderStore, err := addressutil.NormalizeMoveAddress("0x32")
+	if err != nil {
+		t.Fatalf("normalize aptos sender store: %v", err)
+	}
+
+	var generalCalls int
+	general := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		generalCalls++
+		http.Error(w, "general unavailable", http.StatusBadGateway)
+	}))
+	defer general.Close()
+	var manualCalls int
+	manual := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		manualCalls++
+		w.Header().Set("Content-Type", "application/json")
+		switch {
+		case strings.HasPrefix(r.URL.Path, "/v1/transactions/by_hash/"):
+			_, _ = w.Write([]byte(`{"type":"user_transaction","success":true,"hash":"0xabc","version":"101","timestamp":"1700000000123456","payload":{"function":"0x1::primary_fungible_store::transfer","arguments":[{"inner":"` + usdc + `"},"` + receive + `","4200000"],"type":"entry_function_payload"},"events":[{"type":"0x1::fungible_asset::Withdraw","data":{"amount":"4200000","store":"` + senderStore + `"}},{"type":"0x1::fungible_asset::Deposit","data":{"amount":"4200000","store":"` + store + `"}}],"changes":[{"address":"` + senderStore + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdc + `"}}},"type":"write_resource"},{"address":"` + store + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdc + `"}}},"type":"write_resource"},{"address":"` + store + `","data":{"type":"0x1::object::ObjectCore","data":{"owner":"` + receive + `"}},"type":"write_resource"}]}`))
+		case r.URL.Path == "/v1":
+			_, _ = w.Write([]byte(`{"ledger_version":"101"}`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer manual.Close()
+	seedTestAptosRPCNode(t, general.URL, mdb.RpcNodePurposeGeneral, mdb.RpcNodeStatusOk, 100)
+	seedTestAptosRPCNode(t, manual.URL, mdb.RpcNodePurposeManualVerify, mdb.RpcNodeStatusOk, 1)
+
+	order := &mdb.Orders{
+		BaseModel:      mdb.BaseModel{ID: 1, CreatedAt: *carbon.NewTime(carbon.CreateFromTimestampMilli(1699999999000))},
+		Network:        mdb.NetworkAptos,
+		Token:          "USDC",
+		ActualAmount:   4.2,
+		ReceiveAddress: receive,
+	}
+	got, err := ValidateManualAptosPayment(order, "ABC")
+	if err != nil {
+		t.Fatalf("ValidateManualAptosPayment(): %v", err)
+	}
+	if got != "0xabc" {
+		t.Fatalf("canonical tx id = %q, want %q", got, "0xabc")
+	}
+	if generalCalls != 1 || manualCalls != 2 {
+		t.Fatalf("rpc calls general=%d manual=%d, want 1/2", generalCalls, manualCalls)
+	}
+}

src/model/service/move_task.go

@@ -0,0 +1,232 @@
+package service
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	"github.com/GMWalletApp/epusdt/model/request"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
+	"github.com/GMWalletApp/epusdt/util/constant"
+	"github.com/GMWalletApp/epusdt/util/log"
+)
+
+var gProcessedMoveTx sync.Map // transfer-level key -> unix timestamp
+
+var processMoveOrder = OrderProcessing
+
+type MoveObservedTransfer struct {
+	Network        string
+	ReceiveAddress string
+	Token          string
+	RawAmount      *big.Int
+	Decimals       int
+	MinAmount      float64
+	Amount         float64
+	TxID           string
+	BlockTimeMs    int64
+	Version        int64
+	TransferKey    string
+}
+
+func ProcessMoveObservedTransferResult(transfer MoveObservedTransfer) error {
+	net := moveLogLabel(transfer.Network)
+	cacheKey := MoveTransferCacheKey(transfer)
+	now := time.Now().Unix()
+	if _, loaded := gProcessedMoveTx.LoadOrStore(cacheKey, now); loaded {
+		return nil
+	}
+	clearCache := func() {
+		gProcessedMoveTx.Delete(cacheKey)
+	}
+	if transfer.RawAmount == nil || transfer.RawAmount.Sign() <= 0 || transfer.Amount <= 0 {
+		return nil
+	}
+	if transfer.MinAmount > 0 && transfer.Amount < transfer.MinAmount {
+		log.Sugar.Debugf("[%s-%s][%s] skip below min amount tx=%s amount=%.2f min=%.2f", net, transfer.Token, transfer.ReceiveAddress, transfer.TxID, transfer.Amount, transfer.MinAmount)
+		return nil
+	}
+
+	tradeID, err := data.GetTradeIdByWalletAddressAndAmountAndToken(transfer.Network, transfer.ReceiveAddress, transfer.Token, transfer.Amount)
+	if err != nil {
+		clearCache()
+		log.Sugar.Errorf("[%s-%s][%s] lock lookup failed tx=%s: %v", net, transfer.Token, transfer.ReceiveAddress, transfer.TxID, err)
+		return err
+	}
+	if tradeID == "" {
+		raw := ""
+		if transfer.RawAmount != nil {
+			raw = transfer.RawAmount.String()
+		}
+		log.Sugar.Infof("[%s-%s][%s] skip unmatched tx=%s amount=%.8f raw=%s decimals=%d", net, transfer.Token, transfer.ReceiveAddress, transfer.TxID, transfer.Amount, raw, transfer.Decimals)
+		return nil
+	}
+	order, err := data.GetOrderInfoByTradeId(tradeID)
+	if err != nil {
+		clearCache()
+		log.Sugar.Errorf("[%s-%s][%s] load order trade_id=%s tx=%s: %v", net, transfer.Token, transfer.ReceiveAddress, tradeID, transfer.TxID, err)
+		return err
+	}
+	if err := EnsureMoveTransferMatchesOrder(order, transfer); err != nil {
+		log.Sugar.Warnf("[%s-%s][%s] skip tx=%s trade_id=%s: %v", net, transfer.Token, transfer.ReceiveAddress, transfer.TxID, tradeID, err)
+		return nil
+	}
+	req := &request.OrderProcessingRequest{
+		ReceiveAddress:     transfer.ReceiveAddress,
+		Token:              transfer.Token,
+		Network:            transfer.Network,
+		TradeId:            tradeID,
+		Amount:             transfer.Amount,
+		BlockTransactionId: transfer.TxID,
+	}
+	if err = processMoveOrder(req); err != nil {
+		if errors.Is(err, constant.OrderBlockAlreadyProcess) || errors.Is(err, constant.OrderStatusConflict) {
+			log.Sugar.Infof("[%s-%s][%s] already resolved trade_id=%s tx=%s reason=%v", net, transfer.Token, transfer.ReceiveAddress, tradeID, transfer.TxID, err)
+			return nil
+		}
+		clearCache()
+		log.Sugar.Errorf("[%s-%s][%s] OrderProcessing failed trade_id=%s tx=%s: %v", net, transfer.Token, transfer.ReceiveAddress, tradeID, transfer.TxID, err)
+		return err
+	}
+	sendPaymentNotification(order)
+	log.Sugar.Infof("[%s-%s][%s] payment processed trade_id=%s tx=%s", net, transfer.Token, transfer.ReceiveAddress, tradeID, transfer.TxID)
+	return nil
+}
+
+func MoveTransferCacheKey(transfer MoveObservedTransfer) string {
+	if transfer.TransferKey != "" {
+		return strings.ToLower(strings.TrimSpace(transfer.TransferKey))
+	}
+	receive := strings.ToLower(strings.TrimSpace(transfer.ReceiveAddress))
+	token := strings.ToUpper(strings.TrimSpace(transfer.Token))
+	raw := ""
+	if transfer.RawAmount != nil {
+		raw = transfer.RawAmount.String()
+	}
+	switch strings.ToLower(strings.TrimSpace(transfer.Network)) {
+	case mdb.NetworkAptos:
+		return fmt.Sprintf("aptos:%d:%s:%s:%s", transfer.Version, receive, token, raw)
+	default:
+		return strings.ToLower(strings.TrimSpace(transfer.Network)) + ":" + strings.TrimSpace(transfer.TxID)
+	}
+}
+
+func EnsureMoveTransferMatchesOrder(order *mdb.Orders, transfer MoveObservedTransfer) error {
+	if order == nil || order.ID == 0 {
+		return fmt.Errorf("order not found")
+	}
+	if strings.ToLower(strings.TrimSpace(order.Network)) != strings.ToLower(strings.TrimSpace(transfer.Network)) {
+		return fmt.Errorf("network mismatch")
+	}
+	orderAddr, err := addressutil.NormalizeMoveAddress(order.ReceiveAddress)
+	if err != nil {
+		return fmt.Errorf("invalid order receive address: %w", err)
+	}
+	transferAddr, err := addressutil.NormalizeMoveAddress(transfer.ReceiveAddress)
+	if err != nil {
+		return fmt.Errorf("invalid transfer receive address: %w", err)
+	}
+	if orderAddr != transferAddr {
+		return fmt.Errorf("transaction recipient mismatch")
+	}
+	if !strings.EqualFold(order.Token, transfer.Token) {
+		return fmt.Errorf("token mismatch")
+	}
+	if transfer.BlockTimeMs <= 0 {
+		return fmt.Errorf("transaction block time missing")
+	}
+	if transfer.BlockTimeMs < order.CreatedAt.TimestampMilli() {
+		return fmt.Errorf("transaction predates the order")
+	}
+	if !amountMatchesRaw(order.ActualAmount, transfer.RawAmount, transfer.Decimals) {
+		return fmt.Errorf("transaction amount mismatch")
+	}
+	return nil
+}
+
+func moveWalletWatched(address string, wallets map[string]struct{}) bool {
+	if address == "" || len(wallets) == 0 {
+		return false
+	}
+	_, ok := wallets[address]
+	return ok
+}
+
+func moveAptosTransferKey(version int64, eventIndex int, receive, token string, raw *big.Int) string {
+	rawText := ""
+	if raw != nil {
+		rawText = raw.String()
+	}
+	return fmt.Sprintf("aptos:%d:%d:%s:%s:%s", version, eventIndex, strings.ToLower(strings.TrimSpace(receive)), strings.ToUpper(strings.TrimSpace(token)), rawText)
+}
+
+func resolveMoveToken(network, assetID string, tokens []mdb.ChainToken) *mdb.ChainToken {
+	assetID = addressutil.NormalizeMoveAssetID(assetID)
+	for i := range tokens {
+		contract := strings.TrimSpace(tokens[i].ContractAddress)
+		if contract == "" {
+			continue
+		}
+		if addressutil.MoveAssetMatches(assetID, contract) {
+			return &tokens[i]
+		}
+	}
+	return nil
+}
+
+func firstMoveAddress(values ...string) string {
+	for _, v := range values {
+		if normalized, err := addressutil.NormalizeMoveAddress(v); err == nil {
+			return normalized
+		}
+	}
+	return ""
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, v := range values {
+		if strings.TrimSpace(v) != "" {
+			return v
+		}
+	}
+	return ""
+}
+
+func parseSignedBigInt(raw string) (*big.Int, bool) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return nil, false
+	}
+	out, ok := new(big.Int).SetString(raw, 10)
+	return out, ok
+}
+
+func rawToFloat(raw *big.Int, decimals int) float64 {
+	if raw == nil {
+		return 0
+	}
+	value, _ := new(big.Rat).SetFrac(new(big.Int).Set(raw), new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(decimals)), nil)).Float64()
+	return value
+}
+
+func recordMoveRPCResult(network string, errp *error) {
+	if errp != nil && *errp != nil {
+		data.RecordRpcFailure(network)
+		return
+	}
+	data.RecordRpcSuccess(network)
+}
+
+func moveLogLabel(network string) string {
+	switch strings.ToLower(strings.TrimSpace(network)) {
+	case mdb.NetworkAptos:
+		return "APTOS"
+	default:
+		return strings.ToUpper(network)
+	}
+}

src/model/service/move_task_test.go

@@ -0,0 +1,284 @@
+package service
+
+import (
+	"math/big"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
+	"github.com/dromara/carbon/v2"
+)
+
+func TestParseAptosTransfersUSDTAndUSDCFungibleEvents(t *testing.T) {
+	receive, _ := addressutil.NormalizeMoveAddress("0xa")
+	receive2, _ := addressutil.NormalizeMoveAddress("0xb")
+	usdc := "0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b"
+	usdt := "0x357b0b74bc833e95a115ad22604854d6b0fca151cecd94111770e5d6ffc9dc2b"
+	usdcStore, _ := addressutil.NormalizeMoveAddress("0x12")
+	usdcSenderStore, _ := addressutil.NormalizeMoveAddress("0x13")
+	usdtStore, _ := addressutil.NormalizeMoveAddress("0x14")
+	usdtSenderStore, _ := addressutil.NormalizeMoveAddress("0x15")
+	noOwnerStore, _ := addressutil.NormalizeMoveAddress("0x16")
+	body := []byte(`[
+		{
+			"type":"user_transaction",
+			"success":true,
+			"hash":"abc",
+			"version":"101",
+			"timestamp":"1700000000123456",
+			"events":[
+				{"type":"0x1::fungible_asset::Withdraw","data":{"amount":"2500000","store":"` + usdcSenderStore + `"}},
+				{"type":"0x1::fungible_asset::Deposit","data":{"amount":"2500000","store":"` + usdcStore + `"}}
+			],
+			"changes":[
+				{"address":"` + usdcSenderStore + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdc + `"}}},"type":"write_resource"},
+				{"address":"` + usdcStore + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdc + `"}}},"type":"write_resource"},
+				{"address":"` + usdcStore + `","data":{"type":"0x1::object::ObjectCore","data":{"owner":"0xa"}},"type":"write_resource"}
+			]
+		},
+		{
+			"type":"user_transaction",
+			"success":true,
+			"hash":"def",
+			"version":"102",
+			"timestamp":"1700000001123456",
+			"payload":{"function":"0x1::primary_fungible_store::transfer","arguments":[{"inner":"` + usdt + `"},"` + receive2 + `","3100000"],"type":"entry_function_payload"},
+			"events":[
+				{"type":"0x1::fungible_asset::Withdraw","data":{"amount":"3100000","store":"` + usdtSenderStore + `"}},
+				{"type":"0x1::fungible_asset::Deposit","data":{"amount":"3100000","store":"` + usdtStore + `"}}
+			],
+			"changes":[
+				{"address":"` + usdtSenderStore + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdt + `"}}},"type":"write_resource"},
+				{"address":"` + usdtStore + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdt + `"}}},"type":"write_resource"},
+				{"address":"` + usdtStore + `","data":{"type":"0x1::object::ObjectCore","data":{"owner":"` + receive2 + `"}},"type":"write_resource"}
+			]
+		},
+		{
+			"type":"user_transaction",
+			"success":true,
+			"hash":"skip-withdraw-only",
+			"version":"103",
+			"timestamp":"1700000002123456",
+			"events":[
+				{"type":"0x1::fungible_asset::Withdraw","data":{"amount":"4100000","metadata_address":"` + usdc + `"}}
+			]
+		},
+		{
+			"type":"user_transaction",
+			"success":true,
+			"hash":"skip-no-owner",
+			"version":"104",
+			"timestamp":"1700000003123456",
+			"events":[
+				{"type":"0x1::fungible_asset::Withdraw","data":{"amount":"5100000","store":"` + usdcSenderStore + `"}},
+				{"type":"0x1::fungible_asset::Deposit","data":{"amount":"5100000","store":"` + noOwnerStore + `"}}
+			],
+			"changes":[
+				{"address":"` + noOwnerStore + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdc + `"}}},"type":"write_resource"}
+			]
+		},
+		{
+			"type":"user_transaction",
+			"success":false,
+			"hash":"skip-failed",
+			"events":[
+				{"type":"0x1::fungible_asset::Deposit","data":{"to":"` + receive + `","amount":"1","metadata_address":"` + usdc + `"}}
+			]
+		},
+		{
+			"type":"user_transaction",
+			"success":true,
+			"hash":"skip-non-store-owner-fallback",
+			"version":"105",
+			"timestamp":"1700000004123456",
+			"events":[
+				{"type":"0x1::fungible_asset::Withdraw","data":{"amount":"6100000","metadata_address":"` + usdc + `"}},
+				{"type":"0x1::fungible_asset::Deposit","data":{"to":"` + receive + `","amount":"6100000","metadata_address":"` + usdc + `"}}
+			]
+		}
+	]`)
+	tokens := []mdb.ChainToken{
+		{Network: mdb.NetworkAptos, Symbol: "USDC", ContractAddress: usdc, Decimals: 6, Enabled: true, MinAmount: 1},
+		{Network: mdb.NetworkAptos, Symbol: "USDT", ContractAddress: usdt, Decimals: 6, Enabled: true, MinAmount: 3},
+	}
+
+	got, err := ParseAptosTransfers(body, receive, tokens)
+	if err != nil {
+		t.Fatalf("ParseAptosTransfers: %v", err)
+	}
+	if len(got) != 1 {
+		t.Fatalf("transfers len = %d, want 1: %#v", len(got), got)
+	}
+	if got[0].Token != "USDC" || got[0].Amount != 2.5 || got[0].TxID != "0xabc" || got[0].ReceiveAddress != receive {
+		t.Fatalf("usdc transfer = %#v", got[0])
+	}
+	if got[0].TransferKey == "" {
+		t.Fatalf("transfer key should be non-empty: %#v", got[0])
+	}
+	if got[0].MinAmount != 1 {
+		t.Fatalf("usdc min amount = %.2f, want 1", got[0].MinAmount)
+	}
+
+	gotSecondWallet, err := ParseAptosTransfers(body, receive2, tokens)
+	if err != nil {
+		t.Fatalf("ParseAptosTransfers second wallet: %v", err)
+	}
+	if len(gotSecondWallet) != 1 || gotSecondWallet[0].Token != "USDT" || gotSecondWallet[0].Amount != 3.1 || gotSecondWallet[0].TxID != "0xdef" {
+		t.Fatalf("usdt transfer = %#v", gotSecondWallet)
+	}
+}
+
+func TestParseAptosTransfersConfiguredCustomFungibleEvent(t *testing.T) {
+	receive, _ := addressutil.NormalizeMoveAddress("0xa")
+	custom := "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+	store, _ := addressutil.NormalizeMoveAddress("0x21")
+	senderStore, _ := addressutil.NormalizeMoveAddress("0x22")
+	body := []byte(`[
+		{
+			"type":"user_transaction",
+			"success":true,
+			"hash":"custom",
+			"version":"201",
+			"timestamp":"1700000000123456",
+			"events":[
+				{"type":"0x1::fungible_asset::Withdraw","data":{"amount":"7500000","store":"` + senderStore + `"}},
+				{"type":"0x1::fungible_asset::Deposit","data":{"amount":"7500000","store":"` + store + `"}}
+			],
+			"changes":[
+				{"address":"` + senderStore + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + custom + `"}}},"type":"write_resource"},
+				{"address":"` + store + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + custom + `"}}},"type":"write_resource"},
+				{"address":"` + store + `","data":{"type":"0x1::object::ObjectCore","data":{"owner":"` + receive + `"}},"type":"write_resource"}
+			]
+		}
+	]`)
+	tokens := []mdb.ChainToken{
+		{Network: mdb.NetworkAptos, Symbol: "MOVEUSD", ContractAddress: custom, Decimals: 6, Enabled: true},
+	}
+
+	got, err := ParseAptosTransfers(body, receive, tokens)
+	if err != nil {
+		t.Fatalf("ParseAptosTransfers: %v", err)
+	}
+	if len(got) != 1 {
+		t.Fatalf("transfers len = %d, want 1: %#v", len(got), got)
+	}
+	if got[0].Token != "MOVEUSD" || got[0].Amount != 7.5 || got[0].TxID != "0xcustom" {
+		t.Fatalf("custom transfer = %#v", got[0])
+	}
+}
+
+func TestParseAptosTransfersSplitDepositsMatchSingleWithdraw(t *testing.T) {
+	receive, _ := addressutil.NormalizeMoveAddress("0xa")
+	receive2, _ := addressutil.NormalizeMoveAddress("0xb")
+	usdt := "0x357b0b74bc833e95a115ad22604854d6b0fca151cecd94111770e5d6ffc9dc2b"
+	withdrawStore, _ := addressutil.NormalizeMoveAddress("0x21")
+	depositStore, _ := addressutil.NormalizeMoveAddress("0x22")
+	depositStore2, _ := addressutil.NormalizeMoveAddress("0x23")
+	body := []byte(`[
+		{
+			"type":"user_transaction",
+			"success":true,
+			"hash":"split",
+			"version":"201",
+			"timestamp":"1700000000123456",
+			"events":[
+				{"type":"0x1::fungible_asset::Withdraw","data":{"amount":"3000000","store":"` + withdrawStore + `"}},
+				{"type":"0x1::fungible_asset::Deposit","data":{"amount":"1000000","store":"` + depositStore + `"}},
+				{"type":"0x1::fungible_asset::Deposit","data":{"amount":"2000000","store":"` + depositStore2 + `"}}
+			],
+			"changes":[
+				{"address":"` + withdrawStore + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdt + `"}}},"type":"write_resource"},
+				{"address":"` + depositStore + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdt + `"}}},"type":"write_resource"},
+				{"address":"` + depositStore + `","data":{"type":"0x1::object::ObjectCore","data":{"owner":"` + receive + `"}},"type":"write_resource"},
+				{"address":"` + depositStore2 + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdt + `"}}},"type":"write_resource"},
+				{"address":"` + depositStore2 + `","data":{"type":"0x1::object::ObjectCore","data":{"owner":"` + receive2 + `"}},"type":"write_resource"}
+			]
+		}
+	]`)
+	tokens := []mdb.ChainToken{
+		{Network: mdb.NetworkAptos, Symbol: "USDT", ContractAddress: usdt, Decimals: 6, Enabled: true},
+	}
+	wallets := map[string]struct{}{receive: {}, receive2: {}}
+
+	got, err := ParseAptosTransfersForWallets(body, wallets, tokens)
+	if err != nil {
+		t.Fatalf("ParseAptosTransfersForWallets: %v", err)
+	}
+	if len(got) != 2 {
+		t.Fatalf("transfers len = %d, want 2: %#v", len(got), got)
+	}
+	if got[0].Token != "USDT" || got[0].Amount != 1 || got[0].ReceiveAddress != receive || got[0].TxID != "0xsplit" {
+		t.Fatalf("first split transfer = %#v", got[0])
+	}
+	if got[1].Token != "USDT" || got[1].Amount != 2 || got[1].ReceiveAddress != receive2 || got[1].TxID != "0xsplit" {
+		t.Fatalf("second split transfer = %#v", got[1])
+	}
+}
+
+func TestParseAptosTransfersUsesStoreOwnerWhenGuidAccountIsZero(t *testing.T) {
+	receive, _ := addressutil.NormalizeMoveAddress("0xa")
+	usdt := "0x357b0b74bc833e95a115ad22604854d6b0fca151cecd94111770e5d6ffc9dc2b"
+	store, _ := addressutil.NormalizeMoveAddress("0x31")
+	senderStore, _ := addressutil.NormalizeMoveAddress("0x32")
+	body := []byte(`[
+		{
+			"type":"user_transaction",
+			"success":true,
+			"hash":"decimal",
+			"version":"301",
+			"timestamp":"1700000000123456",
+			"events":[
+				{"guid":{"creation_number":"0","account_address":"0x0"},"sequence_number":"0","type":"0x1::fungible_asset::Withdraw","data":{"amount":"10000","store":"` + senderStore + `"}},
+				{"guid":{"creation_number":"0","account_address":"0x0"},"sequence_number":"0","type":"0x1::fungible_asset::Deposit","data":{"amount":"10000","store":"` + store + `"}}
+			],
+			"changes":[
+				{"address":"` + senderStore + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdt + `"}}},"type":"write_resource"},
+				{"address":"` + store + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + usdt + `"}}},"type":"write_resource"},
+				{"address":"` + store + `","data":{"type":"0x1::object::ObjectCore","data":{"owner":"` + receive + `"}},"type":"write_resource"}
+			]
+		}
+	]`)
+	tokens := []mdb.ChainToken{
+		{Network: mdb.NetworkAptos, Symbol: "USDT", ContractAddress: usdt, Decimals: 6, Enabled: true},
+	}
+
+	got, err := ParseAptosTransfers(body, receive, tokens)
+	if err != nil {
+		t.Fatalf("ParseAptosTransfers: %v", err)
+	}
+	if len(got) != 1 {
+		t.Fatalf("transfers len = %d, want 1: %#v", len(got), got)
+	}
+	if got[0].ReceiveAddress != receive || got[0].Decimals != 6 || got[0].Amount != 0.01 || got[0].RawAmount.String() != "10000" {
+		t.Fatalf("transfer amount = %#v", got[0])
+	}
+}
+
+func TestEnsureMoveTransferMatchesOrder(t *testing.T) {
+	receive, _ := addressutil.NormalizeMoveAddress("0xc")
+	order := &mdb.Orders{
+		BaseModel:      mdb.BaseModel{ID: 1, CreatedAt: *carbon.NewTime(carbon.CreateFromTimestampMilli(time.Now().Add(-time.Minute).UnixMilli()))},
+		Network:        mdb.NetworkAptos,
+		Token:          "USDC",
+		ActualAmount:   3.5,
+		ReceiveAddress: strings.ToUpper(receive),
+	}
+	transfer := MoveObservedTransfer{
+		Network:        mdb.NetworkAptos,
+		ReceiveAddress: receive,
+		Token:          "USDC",
+		RawAmount:      big.NewInt(3_500_000),
+		Decimals:       6,
+		BlockTimeMs:    time.Now().UnixMilli(),
+	}
+	if err := EnsureMoveTransferMatchesOrder(order, transfer); err != nil {
+		t.Fatalf("EnsureMoveTransferMatchesOrder: %v", err)
+	}
+
+	transfer.RawAmount = big.NewInt(3_400_000)
+	if err := EnsureMoveTransferMatchesOrder(order, transfer); err == nil || !strings.Contains(err.Error(), "amount") {
+		t.Fatalf("amount mismatch err = %v, want amount error", err)
+	}
+}

src/model/service/okpay_service_test.go

@@ -102,6 +102,79 @@ func TestHandleOkPayNotifySendsPaymentNotificationOnSuccess(t *testing.T) {
 	}
 }
 
+func TestHandleOkPayNotifySettlesPlaceholderParent(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	const (
+		shopID          = "okpay-shop-placeholder"
+		shopToken       = "okpay-shop-placeholder-token"
+		parentTradeID   = "okpay-placeholder-parent-001"
+		providerOrderID = "okpay-placeholder-provider-001"
+	)
+
+	if err := data.SetSetting(mdb.SettingGroupOkPay, mdb.SettingKeyOkPayShopID, shopID, mdb.SettingTypeString); err != nil {
+		t.Fatalf("seed okpay shop id: %v", err)
+	}
+	if err := data.SetSetting(mdb.SettingGroupOkPay, mdb.SettingKeyOkPayShopToken, shopToken, mdb.SettingTypeString); err != nil {
+		t.Fatalf("seed okpay shop token: %v", err)
+	}
+
+	parent := &mdb.Orders{
+		TradeId:        parentTradeID,
+		OrderId:        "merchant-okpay-placeholder-parent-001",
+		Amount:         1,
+		Currency:       "CNY",
+		ActualAmount:   0.15,
+		ReceiveAddress: "OKPAY",
+		Token:          "USDT",
+		Network:        mdb.PaymentProviderOkPay,
+		Status:         mdb.StatusWaitPay,
+		IsSelected:     true,
+		PaymentType:    mdb.PaymentTypeGmpay,
+		PayProvider:    mdb.PaymentProviderOkPay,
+	}
+	if err := dao.Mdb.Create(parent).Error; err != nil {
+		t.Fatalf("seed parent order: %v", err)
+	}
+	if err := dao.Mdb.Create(&mdb.ProviderOrder{
+		TradeId:         parentTradeID,
+		Provider:        mdb.PaymentProviderOkPay,
+		ProviderOrderID: providerOrderID,
+		Amount:          0.15,
+		Coin:            "USDT",
+		Status:          mdb.ProviderOrderStatusPending,
+	}).Error; err != nil {
+		t.Fatalf("seed provider order: %v", err)
+	}
+
+	form := okPayNotifyTestForm(shopID, shopToken, providerOrderID, parentTradeID, "0.15000000", "USDT")
+	if err := HandleOkPayNotify(form, "placeholder-okpay-form"); err != nil {
+		t.Fatalf("handle okpay notify: %v", err)
+	}
+
+	reloadedParent, err := data.GetOrderInfoByTradeId(parentTradeID)
+	if err != nil {
+		t.Fatalf("reload parent: %v", err)
+	}
+	if reloadedParent.Status != mdb.StatusPaySuccess {
+		t.Fatalf("parent status = %d, want %d", reloadedParent.Status, mdb.StatusPaySuccess)
+	}
+	if reloadedParent.PayBySubId != 0 {
+		t.Fatalf("parent pay_by_sub_id = %d, want 0", reloadedParent.PayBySubId)
+	}
+	if reloadedParent.Token != "USDT" || reloadedParent.Network != mdb.PaymentProviderOkPay || reloadedParent.ReceiveAddress != "OKPAY" || reloadedParent.ActualAmount != 0.15 {
+		t.Fatalf("okpay parent fields changed: token=%q network=%q address=%q actual=%v", reloadedParent.Token, reloadedParent.Network, reloadedParent.ReceiveAddress, reloadedParent.ActualAmount)
+	}
+	providerRow, err := data.GetProviderOrderByTradeIDAndProvider(parentTradeID, mdb.PaymentProviderOkPay)
+	if err != nil {
+		t.Fatalf("reload provider row: %v", err)
+	}
+	if providerRow.Status != mdb.ProviderOrderStatusPaid {
+		t.Fatalf("provider status = %q, want %q", providerRow.Status, mdb.ProviderOrderStatusPaid)
+	}
+}
+
 func okPayNotifyTestForm(shopID, shopToken, providerOrderID, tradeID, amount, coin string) map[string]string {
 	form := map[string]string{
 		"code":              "200",

src/model/service/order_service.go

@@ -14,6 +14,7 @@ import (
 	"github.com/GMWalletApp/epusdt/model/mdb"
 	"github.com/GMWalletApp/epusdt/model/request"
 	"github.com/GMWalletApp/epusdt/model/response"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
 	"github.com/GMWalletApp/epusdt/util/constant"
 	"github.com/GMWalletApp/epusdt/util/log"
 	"github.com/GMWalletApp/epusdt/util/math"
@@ -48,40 +49,79 @@ func normalizeOrderAddressByNetwork(network, address string) string {
 	switch network {
 	case mdb.NetworkEthereum, mdb.NetworkBsc, mdb.NetworkPolygon, mdb.NetworkPlasma:
 		return strings.ToLower(address)
+	case mdb.NetworkTon:
+		if normalized, err := addressutil.NormalizeTonAddress(address); err == nil {
+			return normalized
+		}
+		return address
+	case mdb.NetworkAptos:
+		if normalized, err := addressutil.NormalizeMoveAddress(address); err == nil {
+			return normalized
+		}
+		return address
 	default:
 		return address
 	}
 }
 
+func ensureEnabledOrderAsset(network, token string) (*mdb.ChainToken, error) {
+	tokenRow, err := data.GetEnabledChainTokenBySymbol(network, token)
+	if err != nil {
+		return nil, err
+	}
+	if tokenRow == nil || tokenRow.ID == 0 {
+		return nil, constant.SupportedAssetNotFound
+	}
+	if !ChainTokenReadyForPayment(*tokenRow) {
+		return nil, constant.SupportedAssetNotFound
+	}
+	return tokenRow, nil
+}
+
+func validateCreateTransactionTokenNetwork(token, network string) error {
+	if (token == "") != (network == "") {
+		return constant.ParamsMarshalErr
+	}
+	return nil
+}
+
+func buildCreateTransactionResponse(order *mdb.Orders) *response.CreateTransactionResponse {
+	return &response.CreateTransactionResponse{
+		TradeId:        order.TradeId,
+		OrderId:        order.OrderId,
+		Amount:         order.Amount,
+		Currency:       order.Currency,
+		ActualAmount:   order.ActualAmount,
+		ReceiveAddress: order.ReceiveAddress,
+		Token:          order.Token,
+		Status:         order.Status,
+		ExpirationTime: carbon.Now().AddMinutes(config.GetOrderExpirationTime()).Timestamp(),
+		PaymentUrl:     fmt.Sprintf("%s/pay/checkout-counter/%s", config.GetAppUri(), order.TradeId),
+	}
+}
+
 // CreateTransaction creates a new payment order.
 func CreateTransaction(req *request.CreateTransactionRequest, apiKey *mdb.ApiKey) (*response.CreateTransactionResponse, error) {
 	token := strings.ToUpper(strings.TrimSpace(req.Token))
 	currency := strings.ToUpper(strings.TrimSpace(req.Currency))
 	network := strings.ToLower(strings.TrimSpace(req.Network))
+	if err := validateCreateTransactionTokenNetwork(token, network); err != nil {
+		return nil, err
+	}
 	notifyURL := strings.TrimSpace(req.NotifyUrl)
 	if err := security.ValidatePublicHTTPURL(notifyURL); err != nil {
 		return nil, constant.NotifyURLErr
 	}
+	paymentType := mdb.PaymentTypeGmpay
+	if strings.EqualFold(req.PaymentType, mdb.PaymentTypeEpay) {
+		paymentType = mdb.PaymentTypeEpay
+	}
 
 	gCreateTransactionLock.Lock()
 	defer gCreateTransactionLock.Unlock()
 
 	amountPrecision := data.GetAmountPrecision()
 	payAmount := math.MustParsePrecFloat64(req.Amount, amountPrecision)
-	rate := config.GetRateForCoin(strings.ToLower(token), strings.ToLower(currency))
-	if rate <= 0 {
-		return nil, constant.RateAmountErr
-	}
-
-	decimalPayAmount := decimal.NewFromFloat(payAmount)
-	decimalTokenAmount := decimalPayAmount.Mul(decimal.NewFromFloat(rate))
-	if decimalPayAmount.Cmp(decimal.NewFromFloat(CnyMinimumPaymentAmount)) == -1 {
-		return nil, constant.PayAmountErr
-	}
-	if decimalTokenAmount.Cmp(decimal.NewFromFloat(UsdtMinimumPaymentAmount)) == -1 {
-		return nil, constant.PayAmountErr
-	}
-
 	exist, err := data.GetOrderInfoByOrderId(req.OrderId)
 	if err != nil {
 		return nil, err
@@ -90,9 +130,49 @@ func CreateTransaction(req *request.CreateTransactionRequest, apiKey *mdb.ApiKey
 		return nil, constant.OrderAlreadyExists
 	}
 
+	decimalPayAmount := decimal.NewFromFloat(payAmount)
+	if decimalPayAmount.Cmp(decimal.NewFromFloat(CnyMinimumPaymentAmount)) == -1 {
+		return nil, constant.PayAmountErr
+	}
+
+	if token == "" && network == "" {
+		tradeID := GenerateCode()
+		order := &mdb.Orders{
+			TradeId:     tradeID,
+			OrderId:     req.OrderId,
+			Amount:      payAmount,
+			Currency:    currency,
+			Status:      mdb.StatusWaitSelect,
+			NotifyUrl:   notifyURL,
+			RedirectUrl: req.RedirectUrl,
+			Name:        req.Name,
+			PaymentType: paymentType,
+			PayProvider: mdb.PaymentProviderOnChain,
+			ApiKeyID:    apiKeyID(apiKey),
+		}
+		if err = data.CreateOrderWithTransaction(dao.Mdb, order); err != nil {
+			return nil, err
+		}
+		return buildCreateTransactionResponse(order), nil
+	}
+
 	if !data.IsChainEnabled(network) {
 		return nil, constant.ChainNotEnabled
 	}
+	if _, err = ensureEnabledOrderAsset(network, token); err != nil {
+		return nil, err
+	}
+
+	rate := config.GetRateForCoin(strings.ToLower(token), strings.ToLower(currency))
+	if rate <= 0 {
+		return nil, constant.RateAmountErr
+	}
+
+	decimalTokenAmount := decimalPayAmount.Mul(decimal.NewFromFloat(rate))
+	if decimalTokenAmount.Cmp(decimal.NewFromFloat(UsdtMinimumPaymentAmount)) == -1 {
+		return nil, constant.PayAmountErr
+	}
+
 	walletAddress, err := data.GetAvailableWalletAddressByNetwork(network)
 	if err != nil {
 		return nil, err
@@ -125,7 +205,7 @@ func CreateTransaction(req *request.CreateTransactionRequest, apiKey *mdb.ApiKey
 		NotifyUrl:      notifyURL,
 		RedirectUrl:    req.RedirectUrl,
 		Name:           req.Name,
-		PaymentType:    req.PaymentType,
+		PaymentType:    paymentType,
 		PayProvider:    mdb.PaymentProviderOnChain,
 		ApiKeyID:       apiKeyID(apiKey),
 	}
@@ -140,19 +220,7 @@ func CreateTransaction(req *request.CreateTransactionRequest, apiKey *mdb.ApiKey
 		return nil, err
 	}
 
-	expirationTime := carbon.Now().AddMinutes(config.GetOrderExpirationTime()).Timestamp()
+	return buildCreateTransactionResponse(order), nil
-	resp := &response.CreateTransactionResponse{
-		TradeId:        order.TradeId,
-		OrderId:        order.OrderId,
-		Amount:         order.Amount,
-		Currency:       order.Currency,
-		ActualAmount:   order.ActualAmount,
-		ReceiveAddress: order.ReceiveAddress,
-		Token:          order.Token,
-		ExpirationTime: expirationTime,
-		PaymentUrl:     fmt.Sprintf("%s/pay/checkout-counter/%s", config.GetAppUri(), order.TradeId),
-	}
-	return resp, nil
 }
 
 // OrderProcessing marks an order as paid and releases its sqlite reservation.
@@ -185,15 +253,21 @@ func OrderProcessing(req *request.OrderProcessingRequest) error {
 		return err
 	}
 
-	if err = data.UnLockTransaction(req.Network, req.ReceiveAddress, req.Token, req.Amount); err != nil {
-		log.Sugar.Warnf("[order] unlock transaction after pay success failed, trade_id=%s, err=%v", req.TradeId, err)
-	}
-
 	// Load order to check parent-child relationship
 	order, err := data.GetOrderInfoByTradeId(req.TradeId)
 	if err != nil {
+		if strings.TrimSpace(req.Network) != "" && strings.TrimSpace(req.ReceiveAddress) != "" && strings.TrimSpace(req.Token) != "" && req.Amount > 0 {
+			if unlockErr := data.UnLockTransaction(req.Network, req.ReceiveAddress, req.Token, req.Amount); unlockErr != nil {
+				log.Sugar.Warnf("[order] fallback unlock transaction after pay success failed, trade_id=%s, err=%v", req.TradeId, unlockErr)
+			}
+		}
 		return fmt.Errorf("load paid order failed, trade_id=%s: %w", req.TradeId, err)
 	}
+	if hasTransactionLock(order) {
+		if err = data.UnLockTransaction(order.Network, order.ReceiveAddress, order.Token, order.ActualAmount); err != nil {
+			log.Sugar.Warnf("[order] unlock transaction after pay success failed, trade_id=%s, err=%v", order.TradeId, err)
+		}
+	}
 
 	// Parent order paid directly: expire all sub-orders and release their locks
 	if order.ParentTradeId == "" {
@@ -211,10 +285,12 @@ func OrderProcessing(req *request.OrderProcessingRequest) error {
 					log.Sugar.Warnf("[order] expire provider order failed, trade_id=%s, provider=%s, err=%v", sub.TradeId, sub.PayProvider, err)
 				}
 			}
+			if hasTransactionLock(&sub) {
 				if err = data.UnLockTransaction(sub.Network, sub.ReceiveAddress, sub.Token, sub.ActualAmount); err != nil {
 					log.Sugar.Warnf("[order] unlock sub-order transaction failed, trade_id=%s, err=%v", sub.TradeId, err)
 				}
 			}
+		}
 		return nil
 	}
 
@@ -263,9 +339,11 @@ func OrderProcessing(req *request.OrderProcessingRequest) error {
 	}
 
 	// Release parent's own wallet lock
+	if hasTransactionLock(parent) {
 		if err = data.UnLockTransaction(parent.Network, parent.ReceiveAddress, parent.Token, parent.ActualAmount); err != nil {
 			log.Sugar.Warnf("[order] unlock parent transaction failed, parent_trade_id=%s, err=%v", parent.TradeId, err)
 		}
+	}
 
 	// Release sibling locks after their status transitions commit.
 	for _, sib := range siblings {
@@ -274,10 +352,12 @@ func OrderProcessing(req *request.OrderProcessingRequest) error {
 				log.Sugar.Warnf("[order] expire sibling provider order failed, trade_id=%s, provider=%s, err=%v", sib.TradeId, sib.PayProvider, err)
 			}
 		}
+		if hasTransactionLock(&sib) {
 			if err = data.UnLockTransaction(sib.Network, sib.ReceiveAddress, sib.Token, sib.ActualAmount); err != nil {
 				log.Sugar.Warnf("[order] unlock sibling transaction failed, trade_id=%s, err=%v", sib.TradeId, err)
 			}
 		}
+	}
 
 	return nil
 }
@@ -427,9 +507,20 @@ func isOnChainOrder(payProvider string) bool {
 	return payProvider == "" || payProvider == mdb.PaymentProviderOnChain
 }
 
-const MaxSubOrders = 2
+func hasTransactionLock(order *mdb.Orders) bool {
+	return order != nil &&
+		isOnChainOrder(order.PayProvider) &&
+		strings.TrimSpace(order.Network) != "" &&
+		strings.TrimSpace(order.ReceiveAddress) != "" &&
+		strings.TrimSpace(order.Token) != "" &&
+		order.ActualAmount > 0
+}
 
-// SwitchNetwork creates or returns an existing sub-order for a different token+network.
+const MaxSubOrders = 1
+
+// SwitchNetwork completes a status=4 placeholder in place, or creates/returns
+// an existing sub-order for a different payment target once the parent is
+// already concrete.
 func SwitchNetwork(req *request.SwitchNetworkRequest) (*response.CheckoutCounterResponse, error) {
 	gCreateTransactionLock.Lock()
 	defer gCreateTransactionLock.Unlock()
@@ -448,7 +539,7 @@ func SwitchNetwork(req *request.SwitchNetworkRequest) (*response.CheckoutCounter
 	if parent.ParentTradeId != "" {
 		return nil, constant.CannotSwitchSubOrder
 	}
-	if parent.Status != mdb.StatusWaitPay {
+	if parent.Status != mdb.StatusWaitPay && parent.Status != mdb.StatusWaitSelect {
 		return nil, constant.OrderNotWaitPay
 	}
 
@@ -456,6 +547,10 @@ func SwitchNetwork(req *request.SwitchNetworkRequest) (*response.CheckoutCounter
 		return switchToOkPay(parent, token)
 	}
 
+	if parent.Status == mdb.StatusWaitSelect {
+		return completeWaitSelectOrder(parent, token, network)
+	}
+
 	// 2. Same token+network as parent → mark selected and return
 	if strings.EqualFold(parent.Token, token) && strings.EqualFold(parent.Network, network) {
 		_ = data.MarkOrderSelected(parent.TradeId)
@@ -476,8 +571,9 @@ func SwitchNetwork(req *request.SwitchNetworkRequest) (*response.CheckoutCounter
 		return buildCheckoutResponse(existing), nil
 	}
 
-	// 4. Check sub-order limit
+	// 4. Only one sub-order may ever be created under a parent. Existing
-	count, err := data.CountActiveSubOrders(parent.TradeId)
+	// active sub-orders are reused above; any other target after that is blocked.
+	count, err := data.CountSubOrders(parent.TradeId)
 	if err != nil {
 		return nil, err
 	}
@@ -485,7 +581,16 @@ func SwitchNetwork(req *request.SwitchNetworkRequest) (*response.CheckoutCounter
 		return nil, constant.SubOrderLimitExceeded
 	}
 
-	// 5. Calculate amount for the new network
+	// 5. Validate the target chain and asset before any rate lookup so
+	// disabled/unknown tokens return the stable unsupported-asset error.
+	if !data.IsChainEnabled(network) {
+		return nil, constant.ChainNotEnabled
+	}
+	if _, err = ensureEnabledOrderAsset(network, token); err != nil {
+		return nil, err
+	}
+
+	// 6. Calculate amount for the new network
 	rate := config.GetRateForCoin(strings.ToLower(token), strings.ToLower(parent.Currency))
 	if rate <= 0 {
 		return nil, constant.RateAmountErr
@@ -496,10 +601,7 @@ func SwitchNetwork(req *request.SwitchNetworkRequest) (*response.CheckoutCounter
 		return nil, constant.PayAmountErr
 	}
 
-	// 6. Find and lock wallet
+	// 7. Find and lock wallet
-	if !data.IsChainEnabled(network) {
-		return nil, constant.ChainNotEnabled
-	}
 	walletAddress, err := data.GetAvailableWalletAddressByNetwork(network)
 	if err != nil {
 		return nil, err
@@ -518,7 +620,7 @@ func SwitchNetwork(req *request.SwitchNetworkRequest) (*response.CheckoutCounter
 		return nil, constant.NotAvailableAmountErr
 	}
 
-	// 7. Create sub-order
+	// 8. Create sub-order
 	tx := dao.Mdb.Begin()
 	subOrder := &mdb.Orders{
 		TradeId:         subTradeID,
@@ -558,7 +660,63 @@ func SwitchNetwork(req *request.SwitchNetworkRequest) (*response.CheckoutCounter
 	return buildCheckoutResponse(subOrder), nil
 }
 
+func completeWaitSelectOrder(parent *mdb.Orders, token string, network string) (*response.CheckoutCounterResponse, error) {
+	if !data.IsChainEnabled(network) {
+		return nil, constant.ChainNotEnabled
+	}
+	if _, err := ensureEnabledOrderAsset(network, token); err != nil {
+		return nil, err
+	}
+
+	rate := config.GetRateForCoin(strings.ToLower(token), strings.ToLower(parent.Currency))
+	if rate <= 0 {
+		return nil, constant.RateAmountErr
+	}
+	decimalPayAmount := decimal.NewFromFloat(parent.Amount)
+	decimalTokenAmount := decimalPayAmount.Mul(decimal.NewFromFloat(rate))
+	if decimalTokenAmount.Cmp(decimal.NewFromFloat(UsdtMinimumPaymentAmount)) == -1 {
+		return nil, constant.PayAmountErr
+	}
+
+	walletAddress, err := data.GetAvailableWalletAddressByNetwork(network)
+	if err != nil {
+		return nil, err
+	}
+	if len(walletAddress) <= 0 {
+		return nil, constant.NotAvailableWalletAddress
+	}
+
+	amount := math.MustParsePrecFloat64(decimalTokenAmount.InexactFloat64(), data.GetAmountPrecision())
+	availableAddress, availableAmount, err := ReserveAvailableWalletAndAmount(parent.TradeId, network, token, amount, walletAddress)
+	if err != nil {
+		return nil, err
+	}
+	if availableAddress == "" {
+		return nil, constant.NotAvailableAmountErr
+	}
+
+	updated, err := data.CompleteWaitSelectOrder(parent.TradeId, network, token, availableAddress, availableAmount)
+	if err != nil {
+		_ = data.UnLockTransactionByTradeId(parent.TradeId)
+		return nil, err
+	}
+	if !updated {
+		_ = data.UnLockTransactionByTradeId(parent.TradeId)
+		return nil, constant.OrderStatusConflict
+	}
+
+	order, err := data.GetOrderInfoByTradeId(parent.TradeId)
+	if err != nil {
+		return nil, err
+	}
+	return buildCheckoutResponse(order), nil
+}
+
 func buildCheckoutResponse(order *mdb.Orders) *response.CheckoutCounterResponse {
+	paymentType := mdb.PaymentTypeGmpay
+	if isEPayOrder(order) {
+		paymentType = mdb.PaymentTypeEpay
+	}
 	return &response.CheckoutCounterResponse{
 		TradeId:        order.TradeId,
 		Amount:         order.Amount,
@@ -567,14 +725,93 @@ func buildCheckoutResponse(order *mdb.Orders) *response.CheckoutCounterResponse
 		Currency:       order.Currency,
 		ReceiveAddress: order.ReceiveAddress,
 		Network:        order.Network,
+		Status:         order.Status,
+		PaymentType:    strings.ToLower(paymentType),
 		ExpirationTime: order.CreatedAt.AddMinutes(config.GetOrderExpirationTime()).TimestampMilli(),
-		RedirectUrl:    order.RedirectUrl,
+		RedirectUrl:    buildPublicRedirectURL(order),
-		PaymentUrl:     fmt.Sprintf("%s/pay/checkout-counter/%s", config.GetAppUri(), order.TradeId),
 		CreatedAt:      order.CreatedAt.TimestampMilli(),
 		IsSelected:     order.IsSelected,
 	}
 }
 
+func completeWaitSelectOkPayOrder(parent *mdb.Orders, token string) (*response.CheckoutCounterResponse, error) {
+	rate := config.GetRateForCoin(strings.ToLower(token), strings.ToLower(parent.Currency))
+	if rate <= 0 {
+		return nil, constant.RateAmountErr
+	}
+	decimalPayAmount := decimal.NewFromFloat(parent.Amount)
+	decimalTokenAmount := decimalPayAmount.Mul(decimal.NewFromFloat(rate))
+	if decimalTokenAmount.Cmp(decimal.NewFromFloat(UsdtMinimumPaymentAmount)) == -1 {
+		return nil, constant.PayAmountErr
+	}
+
+	amount := math.MustParsePrecFloat64(decimalTokenAmount.InexactFloat64(), data.GetAmountPrecision())
+	returnURL := strings.TrimSpace(parent.RedirectUrl)
+	if returnURL == "" {
+		returnURL = data.GetOkPayReturnURL()
+	}
+	if returnURL == "" {
+		returnURL = fmt.Sprintf("%s/pay/checkout-counter/%s", config.GetAppUri(), parent.TradeId)
+	}
+
+	tx := dao.Mdb.Begin()
+	providerRow := &mdb.ProviderOrder{
+		TradeId:         parent.TradeId,
+		Provider:        mdb.PaymentProviderOkPay,
+		ProviderOrderID: "",
+		PayURL:          "",
+		Amount:          amount,
+		Coin:            token,
+		Status:          mdb.ProviderOrderStatusCreating,
+		NotifyRaw:       "",
+	}
+	if err := data.UpsertProviderOrderCreatingWithTransaction(tx, providerRow); err != nil {
+		tx.Rollback()
+		return nil, err
+	}
+	if err := tx.Commit().Error; err != nil {
+		tx.Rollback()
+		return nil, err
+	}
+
+	okpayOrder, err := createOkPayDepositOrder(parent.TradeId, amount, token, returnURL)
+	if err != nil {
+		_ = data.MarkProviderOrderFailed(parent.TradeId, mdb.PaymentProviderOkPay)
+		return nil, constant.PaymentProviderCreateErr
+	}
+
+	finalizeTx := dao.Mdb.Begin()
+	if err = data.UpdateProviderOrderCreatedWithTransaction(finalizeTx, parent.TradeId, mdb.PaymentProviderOkPay, okpayOrder.ProviderOrderID, okpayOrder.PayURL); err != nil {
+		finalizeTx.Rollback()
+		_ = data.MarkProviderOrderFailed(parent.TradeId, mdb.PaymentProviderOkPay)
+		return nil, err
+	}
+	updated, err := data.CompleteWaitSelectOkPayOrderWithTransaction(finalizeTx, parent.TradeId, token, amount)
+	if err != nil {
+		finalizeTx.Rollback()
+		_ = data.MarkProviderOrderFailed(parent.TradeId, mdb.PaymentProviderOkPay)
+		return nil, err
+	}
+	if !updated {
+		finalizeTx.Rollback()
+		_ = data.MarkProviderOrderFailed(parent.TradeId, mdb.PaymentProviderOkPay)
+		return nil, constant.OrderStatusConflict
+	}
+	if err = finalizeTx.Commit().Error; err != nil {
+		finalizeTx.Rollback()
+		_ = data.MarkProviderOrderFailed(parent.TradeId, mdb.PaymentProviderOkPay)
+		return nil, err
+	}
+
+	order, err := data.GetOrderInfoByTradeId(parent.TradeId)
+	if err != nil {
+		return nil, err
+	}
+	resp := buildCheckoutResponse(order)
+	resp.PaymentUrl = okpayOrder.PayURL
+	return resp, nil
+}
+
 func switchToOkPay(parent *mdb.Orders, token string) (*response.CheckoutCounterResponse, error) {
 	if !data.GetOkPayEnabled() {
 		return nil, constant.PaymentProviderNotEnabled
@@ -586,6 +823,29 @@ func switchToOkPay(parent *mdb.Orders, token string) (*response.CheckoutCounterR
 		return nil, constant.PaymentProviderNotSupport
 	}
 
+	if parent.Status == mdb.StatusWaitSelect {
+		return completeWaitSelectOkPayOrder(parent, token)
+	}
+
+	if parent.PayProvider == mdb.PaymentProviderOkPay && strings.EqualFold(parent.Token, token) {
+		providerRow, err := data.GetProviderOrderByTradeIDAndProvider(parent.TradeId, mdb.PaymentProviderOkPay)
+		if err != nil {
+			return nil, err
+		}
+		if providerRow.ID == 0 || strings.TrimSpace(providerRow.PayURL) == "" {
+			return nil, constant.SystemErr
+		}
+		_ = data.MarkOrderSelected(parent.TradeId)
+		_ = data.RefreshOrderExpiration(parent.TradeId)
+		order, err := data.GetOrderInfoByTradeId(parent.TradeId)
+		if err != nil {
+			return nil, err
+		}
+		resp := buildCheckoutResponse(order)
+		resp.PaymentUrl = providerRow.PayURL
+		return resp, nil
+	}
+
 	existing, err := data.GetSubOrderByTokenPayProvider(parent.TradeId, token, mdb.PaymentProviderOkPay)
 	if err != nil {
 		return nil, err
@@ -598,16 +858,21 @@ func switchToOkPay(parent *mdb.Orders, token string) (*response.CheckoutCounterR
 		if providerRow.ID == 0 || strings.TrimSpace(providerRow.PayURL) == "" {
 			return nil, constant.SystemErr
 		}
-		_ = data.MarkOrderSelected(parent.TradeId)
+		updated, markErr := data.MarkProviderSwitchParentSelectedWithTransaction(dao.Mdb, parent.TradeId)
+		if markErr != nil {
+			return nil, markErr
+		}
+		if !updated {
+			return nil, constant.OrderStatusConflict
+		}
 		_ = data.MarkOrderSelected(existing.TradeId)
-		_ = data.RefreshOrderExpiration(parent.TradeId)
 		existing.IsSelected = true
 		resp := buildCheckoutResponse(existing)
 		resp.PaymentUrl = providerRow.PayURL
 		return resp, nil
 	}
 
-	count, err := data.CountActiveSubOrders(parent.TradeId)
+	count, err := data.CountSubOrders(parent.TradeId)
 	if err != nil {
 		return nil, err
 	}
@@ -684,14 +949,33 @@ func switchToOkPay(parent *mdb.Orders, token string) (*response.CheckoutCounterR
 		_ = data.ExpireOrderByTradeID(subTradeID)
 		return nil, constant.PaymentProviderCreateErr
 	}
-	if err = data.UpdateProviderOrderCreated(subTradeID, mdb.PaymentProviderOkPay, okpayOrder.ProviderOrderID, okpayOrder.PayURL); err != nil {
+
+	finalizeTx := dao.Mdb.Begin()
+	if err = data.UpdateProviderOrderCreatedWithTransaction(finalizeTx, subTradeID, mdb.PaymentProviderOkPay, okpayOrder.ProviderOrderID, okpayOrder.PayURL); err != nil {
+		finalizeTx.Rollback()
+		_ = data.MarkProviderOrderFailed(subTradeID, mdb.PaymentProviderOkPay)
+		_ = data.ExpireOrderByTradeID(subTradeID)
+		return nil, err
+	}
+	updated, err := data.MarkProviderSwitchParentSelectedWithTransaction(finalizeTx, parent.TradeId)
+	if err != nil {
+		finalizeTx.Rollback()
+		_ = data.MarkProviderOrderFailed(subTradeID, mdb.PaymentProviderOkPay)
+		_ = data.ExpireOrderByTradeID(subTradeID)
+		return nil, err
+	}
+	if !updated {
+		finalizeTx.Rollback()
+		_ = data.MarkProviderOrderFailed(subTradeID, mdb.PaymentProviderOkPay)
+		_ = data.ExpireOrderByTradeID(subTradeID)
+		return nil, constant.OrderStatusConflict
+	}
+	if err = finalizeTx.Commit().Error; err != nil {
+		finalizeTx.Rollback()
 		_ = data.MarkProviderOrderFailed(subTradeID, mdb.PaymentProviderOkPay)
 		_ = data.ExpireOrderByTradeID(subTradeID)
 		return nil, err
 	}
-
-	_ = data.MarkOrderSelected(parent.TradeId)
-	_ = data.RefreshOrderExpiration(parent.TradeId)
 
 	resp := buildCheckoutResponse(subOrder)
 	resp.PaymentUrl = okpayOrder.PayURL

src/model/service/order_service_test.go

@@ -4,6 +4,7 @@ import (
 	"encoding/base64"
 	"fmt"
 	"io"
+	"math/big"
 	"net/http"
 	"strings"
 	"sync"
@@ -18,6 +19,7 @@ import (
 	"github.com/GMWalletApp/epusdt/util/constant"
 	"github.com/GMWalletApp/epusdt/util/http_client"
 	"github.com/go-resty/resty/v2"
+	"github.com/xssnick/tonutils-go/address"
 )
 
 func newCreateTransactionRequest(orderID string, amount float64) *request.CreateTransactionRequest {
@@ -85,6 +87,85 @@ func TestCreateTransactionRejectsPrivateNotifyURL(t *testing.T) {
 	}
 }
 
+func TestCreateTransactionCreatesWaitSelectPlaceholderWithoutTokenNetwork(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	req := newCreateTransactionRequest("order_wait_select_1", 12.34)
+	req.Token = ""
+	req.Network = ""
+	resp, err := CreateTransaction(req, nil)
+	if err != nil {
+		t.Fatalf("create placeholder transaction: %v", err)
+	}
+	if resp.Status != mdb.StatusWaitSelect {
+		t.Fatalf("response status = %d, want %d", resp.Status, mdb.StatusWaitSelect)
+	}
+	if resp.Token != "" || resp.ReceiveAddress != "" || resp.ActualAmount != 0 {
+		t.Fatalf("placeholder chain fields = token %q address %q actual %.4f", resp.Token, resp.ReceiveAddress, resp.ActualAmount)
+	}
+
+	order, err := data.GetOrderInfoByTradeId(resp.TradeId)
+	if err != nil {
+		t.Fatalf("reload placeholder order: %v", err)
+	}
+	if order.Status != mdb.StatusWaitSelect {
+		t.Fatalf("order status = %d, want %d", order.Status, mdb.StatusWaitSelect)
+	}
+	if order.PaymentType != mdb.PaymentTypeGmpay {
+		t.Fatalf("placeholder payment_type = %q, want %q", order.PaymentType, mdb.PaymentTypeGmpay)
+	}
+	if order.Token != "" || order.Network != "" || order.ReceiveAddress != "" || order.ActualAmount != 0 {
+		t.Fatalf("placeholder order has chain fields: %+v", order)
+	}
+
+	var locks int64
+	if err := dao.RuntimeDB.Model(&mdb.TransactionLock{}).Where("trade_id = ?", resp.TradeId).Count(&locks).Error; err != nil {
+		t.Fatalf("count transaction locks: %v", err)
+	}
+	if locks != 0 {
+		t.Fatalf("placeholder lock count = %d, want 0", locks)
+	}
+}
+
+func TestCreateTransactionRejectsPartialTokenNetwork(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	req := newCreateTransactionRequest("order_partial_token_network_1", 1)
+	req.Token = ""
+	if _, err := CreateTransaction(req, nil); err != constant.ParamsMarshalErr {
+		t.Fatalf("missing token error = %v, want %v", err, constant.ParamsMarshalErr)
+	}
+
+	req = newCreateTransactionRequest("order_partial_token_network_2", 1)
+	req.Network = ""
+	if _, err := CreateTransaction(req, nil); err != constant.ParamsMarshalErr {
+		t.Fatalf("missing network error = %v, want %v", err, constant.ParamsMarshalErr)
+	}
+}
+
+func TestCreateTransactionNormalizesEpayPaymentTypeCase(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	req := newCreateTransactionRequest("order_epay_payment_type_1", 1)
+	req.Token = ""
+	req.Network = ""
+	req.PaymentType = "epay"
+	resp, err := CreateTransaction(req, nil)
+	if err != nil {
+		t.Fatalf("create epay-compatible transaction: %v", err)
+	}
+	order, err := data.GetOrderInfoByTradeId(resp.TradeId)
+	if err != nil {
+		t.Fatalf("reload order: %v", err)
+	}
+	if order.PaymentType != mdb.PaymentTypeEpay {
+		t.Fatalf("payment_type = %q, want %q", order.PaymentType, mdb.PaymentTypeEpay)
+	}
+}
+
 func TestCreateTransactionAssignsIncrementedAmountsAndLocks(t *testing.T) {
 	cleanup := testutil.SetupTestDatabases(t)
 	defer cleanup()
@@ -281,6 +362,614 @@ func TestCreateTransactionNormalizesEvmReceiveAddressToLowercase(t *testing.T) {
 	}
 }
 
+func TestCreateTransactionCreatesTonOrderAndRawLock(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := data.SetSetting("rate", "rate.forced_rate_list", `{"cny":{"ton":0.5}}`, "json"); err != nil {
+		t.Fatalf("set forced rate: %v", err)
+	}
+	addr := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	wallet, err := data.AddWalletAddressWithNetwork(mdb.NetworkTon, addr.StringRaw())
+	if err != nil {
+		t.Fatalf("add ton wallet: %v", err)
+	}
+
+	req := newCreateTransactionRequest("order_ton_native_1", 10)
+	req.Network = mdb.NetworkTon
+	req.Token = "TON"
+
+	resp, err := CreateTransaction(req, nil)
+	if err != nil {
+		t.Fatalf("create TON transaction: %v", err)
+	}
+	if resp.ReceiveAddress != wallet.Address {
+		t.Fatalf("receive address = %q, want %q", resp.ReceiveAddress, wallet.Address)
+	}
+	if resp.Token != "TON" {
+		t.Fatalf("token = %q, want TON", resp.Token)
+	}
+	if got := fmt.Sprintf("%.2f", resp.ActualAmount); got != "5.00" {
+		t.Fatalf("actual amount = %s, want 5.00", got)
+	}
+
+	tradeID, err := data.GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkTon, addr.StringRaw(), "TON", resp.ActualAmount)
+	if err != nil {
+		t.Fatalf("lookup ton runtime lock: %v", err)
+	}
+	if tradeID != resp.TradeId {
+		t.Fatalf("runtime lock trade_id = %q, want %q", tradeID, resp.TradeId)
+	}
+}
+
+func TestCreateTransactionCreatesTonOrderWithConfiguredPrecision(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := data.SetSetting(mdb.SettingGroupSystem, mdb.SettingKeyAmountPrecision, "4", mdb.SettingTypeInt); err != nil {
+		t.Fatalf("set amount precision: %v", err)
+	}
+	if err := data.SetSetting("rate", "rate.forced_rate_list", `{"cny":{"ton":0.12345}}`, "json"); err != nil {
+		t.Fatalf("set forced rate: %v", err)
+	}
+	addr := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	if _, err := data.AddWalletAddressWithNetwork(mdb.NetworkTon, addr.StringRaw()); err != nil {
+		t.Fatalf("add ton wallet: %v", err)
+	}
+
+	req := newCreateTransactionRequest("order_ton_precision_1", 10)
+	req.Network = mdb.NetworkTon
+	req.Token = "TON"
+	resp, err := CreateTransaction(req, nil)
+	if err != nil {
+		t.Fatalf("create TON transaction: %v", err)
+	}
+	if got := fmt.Sprintf("%.4f", resp.ActualAmount); got != "1.2345" {
+		t.Fatalf("actual amount = %s, want 1.2345", got)
+	}
+	tradeID, err := data.GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkTon, addr.Bounce(true).String(), "TON", 1.2345)
+	if err != nil {
+		t.Fatalf("lookup ton runtime lock: %v", err)
+	}
+	if tradeID != resp.TradeId {
+		t.Fatalf("runtime lock trade_id = %q, want %q", tradeID, resp.TradeId)
+	}
+}
+
+func TestCreateTransactionRejectsUnsupportedTonToken(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	req := newCreateTransactionRequest("order_ton_gram_1", 10)
+	req.Network = mdb.NetworkTon
+	req.Token = "GRAM"
+
+	_, err := CreateTransaction(req, nil)
+	if err != constant.SupportedAssetNotFound {
+		t.Fatalf("create unsupported TON token error = %v, want %v", err, constant.SupportedAssetNotFound)
+	}
+}
+
+func TestCreateTransactionRejectsDisabledTonTokenBeforeRate(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := dao.Mdb.Model(&mdb.ChainToken{}).
+		Where("network = ? AND symbol = ?", mdb.NetworkTon, "TON").
+		Update("enabled", false).Error; err != nil {
+		t.Fatalf("disable TON token: %v", err)
+	}
+	req := newCreateTransactionRequest("order_ton_disabled_1", 10)
+	req.Network = mdb.NetworkTon
+	req.Token = "TON"
+
+	_, err := CreateTransaction(req, nil)
+	if err != constant.SupportedAssetNotFound {
+		t.Fatalf("create disabled TON token error = %v, want %v", err, constant.SupportedAssetNotFound)
+	}
+}
+
+func TestCreateTransactionRejectsEnabledMisconfiguredAptosUSDT(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := dao.Mdb.Create(&mdb.Chain{Network: mdb.NetworkAptos, Enabled: true}).Error; err != nil {
+		t.Fatalf("create aptos chain: %v", err)
+	}
+	if err := dao.Mdb.Create(&mdb.ChainToken{
+		Network:         mdb.NetworkAptos,
+		Symbol:          "USDT",
+		ContractAddress: "",
+		Decimals:        6,
+		Enabled:         true,
+	}).Error; err != nil {
+		t.Fatalf("create aptos usdt token: %v", err)
+	}
+
+	req := newCreateTransactionRequest("order_aptos_misconfigured_usdt_1", 10)
+	req.Network = mdb.NetworkAptos
+	req.Token = "USDT"
+
+	_, err := CreateTransaction(req, nil)
+	if err != constant.SupportedAssetNotFound {
+		t.Fatalf("create misconfigured Aptos USDT error = %v, want %v", err, constant.SupportedAssetNotFound)
+	}
+}
+
+func TestEnsureEnabledOrderAssetAllowsConfiguredAptosCustomToken(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := dao.Mdb.Create(&mdb.ChainToken{
+		Network:         mdb.NetworkAptos,
+		Symbol:          "MOVEUSD",
+		ContractAddress: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+		Decimals:        6,
+		Enabled:         true,
+	}).Error; err != nil {
+		t.Fatalf("create aptos custom token: %v", err)
+	}
+
+	token, err := ensureEnabledOrderAsset(mdb.NetworkAptos, "MOVEUSD")
+	if err != nil {
+		t.Fatalf("ensureEnabledOrderAsset(): %v", err)
+	}
+	if token.Symbol != "MOVEUSD" {
+		t.Fatalf("token symbol = %q, want MOVEUSD", token.Symbol)
+	}
+}
+
+func TestCreateTransactionSupportedTonTokenWithoutRateReturnsRateError(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := data.SetSetting("rate", "rate.forced_rate_list", `{"cny":{"ton":0}}`, "json"); err != nil {
+		t.Fatalf("set forced rate: %v", err)
+	}
+	if err := data.SetSetting("rate", "rate.api_url", "", "string"); err != nil {
+		t.Fatalf("clear rate api url: %v", err)
+	}
+	req := newCreateTransactionRequest("order_ton_missing_rate_1", 10)
+	req.Network = mdb.NetworkTon
+	req.Token = "TON"
+
+	_, err := CreateTransaction(req, nil)
+	if err != constant.RateAmountErr {
+		t.Fatalf("create TON without rate error = %v, want %v", err, constant.RateAmountErr)
+	}
+}
+
+func TestSwitchNetworkCreatesTonSubOrderAndRawLock(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := data.SetSetting("rate", "rate.forced_rate_list", `{"cny":{"usdt":0.1,"ton":0.5}}`, "json"); err != nil {
+		t.Fatalf("set forced rate: %v", err)
+	}
+	if _, err := data.AddWalletAddress("TTestTronAddress001"); err != nil {
+		t.Fatalf("add tron wallet: %v", err)
+	}
+	addr := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	wallet, err := data.AddWalletAddressWithNetwork(mdb.NetworkTon, addr.StringRaw())
+	if err != nil {
+		t.Fatalf("add ton wallet: %v", err)
+	}
+
+	parentReq := newCreateTransactionRequest("order_switch_ton_1", 10)
+	parentReq.Network = mdb.NetworkTron
+	parentResp, err := CreateTransaction(parentReq, nil)
+	if err != nil {
+		t.Fatalf("create parent transaction: %v", err)
+	}
+
+	subResp, err := SwitchNetwork(&request.SwitchNetworkRequest{
+		TradeId: parentResp.TradeId,
+		Token:   "TON",
+		Network: mdb.NetworkTon,
+	})
+	if err != nil {
+		t.Fatalf("switch to TON: %v", err)
+	}
+	if subResp.Network != mdb.NetworkTon || subResp.Token != "TON" {
+		t.Fatalf("sub order network/token = %s/%s, want ton/TON", subResp.Network, subResp.Token)
+	}
+	if subResp.ReceiveAddress != wallet.Address {
+		t.Fatalf("sub order receive address = %q, want %q", subResp.ReceiveAddress, wallet.Address)
+	}
+	if got := fmt.Sprintf("%.2f", subResp.ActualAmount); got != "5.00" {
+		t.Fatalf("sub order actual amount = %s, want 5.00", got)
+	}
+	tradeID, err := data.GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkTon, addr.StringRaw(), "TON", subResp.ActualAmount)
+	if err != nil {
+		t.Fatalf("lookup TON sub-order lock: %v", err)
+	}
+	if tradeID != subResp.TradeId {
+		t.Fatalf("TON sub-order lock trade_id = %q, want %q", tradeID, subResp.TradeId)
+	}
+}
+
+func TestSwitchNetworkCompletesWaitSelectPlaceholderInPlace(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := data.SetSetting("rate", "rate.forced_rate_list", `{"cny":{"usdt":0.1}}`, "json"); err != nil {
+		t.Fatalf("set forced rate: %v", err)
+	}
+	if _, err := data.AddWalletAddress("TWaitSelectAddress001"); err != nil {
+		t.Fatalf("add tron wallet: %v", err)
+	}
+
+	req := newCreateTransactionRequest("order_wait_select_switch_1", 10)
+	req.Token = ""
+	req.Network = ""
+	parentResp, err := CreateTransaction(req, nil)
+	if err != nil {
+		t.Fatalf("create placeholder: %v", err)
+	}
+	if parentResp.Status != mdb.StatusWaitSelect {
+		t.Fatalf("parent response status = %d, want %d", parentResp.Status, mdb.StatusWaitSelect)
+	}
+
+	switched, err := SwitchNetwork(&request.SwitchNetworkRequest{
+		TradeId: parentResp.TradeId,
+		Token:   "USDT",
+		Network: mdb.NetworkTron,
+	})
+	if err != nil {
+		t.Fatalf("switch placeholder to tron/usdt: %v", err)
+	}
+	if switched.TradeId != parentResp.TradeId {
+		t.Fatalf("switch returned trade_id = %q, want parent %q", switched.TradeId, parentResp.TradeId)
+	}
+	if switched.Status != mdb.StatusWaitPay {
+		t.Fatalf("switch status = %d, want %d", switched.Status, mdb.StatusWaitPay)
+	}
+	if switched.IsSelected {
+		t.Fatal("switch is_selected = true, want false")
+	}
+	if switched.PaymentUrl != "" {
+		t.Fatalf("switch payment_url = %q, want empty for unselected chain parent", switched.PaymentUrl)
+	}
+	if switched.Token != "USDT" || switched.Network != mdb.NetworkTron || switched.ReceiveAddress != "TWaitSelectAddress001" {
+		t.Fatalf("switch chain fields = token %q network %q address %q", switched.Token, switched.Network, switched.ReceiveAddress)
+	}
+	if got := fmt.Sprintf("%.2f", switched.ActualAmount); got != "1.00" {
+		t.Fatalf("switch actual amount = %s, want 1.00", got)
+	}
+
+	parent, err := data.GetOrderInfoByTradeId(parentResp.TradeId)
+	if err != nil {
+		t.Fatalf("reload parent: %v", err)
+	}
+	if parent.Status != mdb.StatusWaitPay || parent.ParentTradeId != "" {
+		t.Fatalf("parent status/parent_trade_id = %d/%q", parent.Status, parent.ParentTradeId)
+	}
+	if parent.IsSelected {
+		t.Fatal("parent is_selected = true, want false")
+	}
+	if parent.PaymentType != mdb.PaymentTypeGmpay {
+		t.Fatalf("parent payment_type = %q, want %q", parent.PaymentType, mdb.PaymentTypeGmpay)
+	}
+	count, err := data.CountActiveSubOrders(parent.TradeId)
+	if err != nil {
+		t.Fatalf("count sub orders: %v", err)
+	}
+	if count != 0 {
+		t.Fatalf("active sub-order count = %d, want 0", count)
+	}
+	lockTradeID, err := data.GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkTron, parent.ReceiveAddress, parent.Token, parent.ActualAmount)
+	if err != nil {
+		t.Fatalf("lookup parent lock: %v", err)
+	}
+	if lockTradeID != parent.TradeId {
+		t.Fatalf("parent lock trade_id = %q, want %q", lockTradeID, parent.TradeId)
+	}
+}
+
+func TestSwitchNetworkAfterWaitSelectCompletionUsesExistingSubOrderFlow(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := data.SetSetting("rate", "rate.forced_rate_list", `{"cny":{"usdt":0.1}}`, "json"); err != nil {
+		t.Fatalf("set forced rate: %v", err)
+	}
+	if _, err := data.AddWalletAddress("TWaitSelectAddress002"); err != nil {
+		t.Fatalf("add tron wallet: %v", err)
+	}
+	if _, err := data.AddWalletAddressWithNetwork(mdb.NetworkEthereum, "0xA1B2c3D4e5F60718293aBcDeF001122334455668"); err != nil {
+		t.Fatalf("add ethereum wallet: %v", err)
+	}
+
+	req := newCreateTransactionRequest("order_wait_select_reswitch_1", 10)
+	req.Token = ""
+	req.Network = ""
+	parentResp, err := CreateTransaction(req, nil)
+	if err != nil {
+		t.Fatalf("create placeholder: %v", err)
+	}
+	first, err := SwitchNetwork(&request.SwitchNetworkRequest{
+		TradeId: parentResp.TradeId,
+		Token:   "USDT",
+		Network: mdb.NetworkTron,
+	})
+	if err != nil {
+		t.Fatalf("first switch: %v", err)
+	}
+
+	second, err := SwitchNetwork(&request.SwitchNetworkRequest{
+		TradeId: parentResp.TradeId,
+		Token:   "USDT",
+		Network: mdb.NetworkEthereum,
+	})
+	if err != nil {
+		t.Fatalf("second switch: %v", err)
+	}
+	if second.TradeId == first.TradeId {
+		t.Fatalf("second switch trade_id = parent %q, want sub-order", second.TradeId)
+	}
+	if second.Network != mdb.NetworkEthereum || second.Token != "USDT" {
+		t.Fatalf("second switch token/network = %s/%s", second.Token, second.Network)
+	}
+	count, err := data.CountActiveSubOrders(parentResp.TradeId)
+	if err != nil {
+		t.Fatalf("count active sub orders: %v", err)
+	}
+	if count != 1 {
+		t.Fatalf("active sub-order count = %d, want 1", count)
+	}
+
+	_, err = SwitchNetwork(&request.SwitchNetworkRequest{
+		TradeId: parentResp.TradeId,
+		Token:   "USDT",
+		Network: mdb.NetworkBsc,
+	})
+	if err != constant.SubOrderLimitExceeded {
+		t.Fatalf("third switch error = %v, want %v", err, constant.SubOrderLimitExceeded)
+	}
+}
+
+func TestSwitchNetworkRejectsUnsupportedTonToken(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := data.SetSetting("rate", "rate.forced_rate_list", `{"cny":{"usdt":0.1}}`, "json"); err != nil {
+		t.Fatalf("set forced rate: %v", err)
+	}
+	if _, err := data.AddWalletAddress("TTestTronAddress002"); err != nil {
+		t.Fatalf("add tron wallet: %v", err)
+	}
+	parentResp, err := CreateTransaction(newCreateTransactionRequest("order_switch_gram_1", 10), nil)
+	if err != nil {
+		t.Fatalf("create parent transaction: %v", err)
+	}
+
+	_, err = SwitchNetwork(&request.SwitchNetworkRequest{
+		TradeId: parentResp.TradeId,
+		Token:   "GRAM",
+		Network: mdb.NetworkTon,
+	})
+	if err != constant.SupportedAssetNotFound {
+		t.Fatalf("switch unsupported TON token error = %v, want %v", err, constant.SupportedAssetNotFound)
+	}
+}
+
+func TestTryProcessTonTransferMarksOrderPaidAndReleasesRawLock(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := data.SetSetting("rate", "rate.forced_rate_list", `{"cny":{"ton":0.5}}`, "json"); err != nil {
+		t.Fatalf("set forced rate: %v", err)
+	}
+	addr := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	if _, err := data.AddWalletAddressWithNetwork(mdb.NetworkTon, addr.StringRaw()); err != nil {
+		t.Fatalf("add ton wallet: %v", err)
+	}
+	req := newCreateTransactionRequest("order_ton_process_1", 10)
+	req.Network = mdb.NetworkTon
+	req.Token = "TON"
+	resp, err := CreateTransaction(req, nil)
+	if err != nil {
+		t.Fatalf("create TON transaction: %v", err)
+	}
+
+	transfer := &TonObservedTransfer{
+		ReceiveAddress: resp.ReceiveAddress,
+		Token:          mdb.ChainToken{BaseModel: mdb.BaseModel{ID: 1}, Network: mdb.NetworkTon, Symbol: "TON", Decimals: 9, Enabled: true},
+		RawAmount:      big.NewInt(5_000_000_000),
+		Amount:         resp.ActualAmount,
+		BlockTimeMs:    time.Now().Add(time.Second).UnixMilli(),
+		LT:             100,
+		TxHashHex:      strings.Repeat("1", 64),
+		BlockID:        TonCanonicalBlockTransactionID(addr.StringRaw(), 100, strings.Repeat("1", 64)),
+	}
+	TryProcessTonTransfer(transfer)
+
+	order, err := data.GetOrderInfoByTradeId(resp.TradeId)
+	if err != nil {
+		t.Fatalf("reload order: %v", err)
+	}
+	if order.Status != mdb.StatusPaySuccess {
+		t.Fatalf("order status = %d, want %d", order.Status, mdb.StatusPaySuccess)
+	}
+	if order.BlockTransactionId != transfer.BlockID {
+		t.Fatalf("block transaction id = %q, want %q", order.BlockTransactionId, transfer.BlockID)
+	}
+	lock, err := data.GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkTon, addr.StringRaw(), "TON", resp.ActualAmount)
+	if err != nil {
+		t.Fatalf("lookup ton lock: %v", err)
+	}
+	if lock != "" {
+		t.Fatalf("TON lock still exists after payment: %s", lock)
+	}
+}
+
+func TestTryProcessTonJettonTransferMarksUSDTOrderPaid(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := data.SetSetting("rate", "rate.forced_rate_list", `{"cny":{"usdt":0.1}}`, "json"); err != nil {
+		t.Fatalf("set forced rate: %v", err)
+	}
+	addr := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	if _, err := data.AddWalletAddressWithNetwork(mdb.NetworkTon, addr.StringRaw()); err != nil {
+		t.Fatalf("add ton wallet: %v", err)
+	}
+	req := newCreateTransactionRequest("order_ton_usdt_process_1", 10)
+	req.Network = mdb.NetworkTon
+	req.Token = "USDT"
+	resp, err := CreateTransaction(req, nil)
+	if err != nil {
+		t.Fatalf("create TON USDT transaction: %v", err)
+	}
+
+	transfer := &TonObservedTransfer{
+		ReceiveAddress: resp.ReceiveAddress,
+		Token:          mdb.ChainToken{BaseModel: mdb.BaseModel{ID: 2}, Network: mdb.NetworkTon, Symbol: "USDT", Decimals: 6, Enabled: true},
+		RawAmount:      big.NewInt(1_000_000),
+		Amount:         resp.ActualAmount,
+		BlockTimeMs:    time.Now().Add(time.Second).UnixMilli(),
+		LT:             110,
+		TxHashHex:      strings.Repeat("4", 64),
+		BlockID:        TonCanonicalBlockTransactionID(addr.StringRaw(), 110, strings.Repeat("4", 64)),
+	}
+	TryProcessTonTransfer(transfer)
+
+	order, err := data.GetOrderInfoByTradeId(resp.TradeId)
+	if err != nil {
+		t.Fatalf("reload order: %v", err)
+	}
+	if order.Status != mdb.StatusPaySuccess {
+		t.Fatalf("order status = %d, want %d", order.Status, mdb.StatusPaySuccess)
+	}
+	if order.BlockTransactionId != transfer.BlockID {
+		t.Fatalf("block transaction id = %q, want %q", order.BlockTransactionId, transfer.BlockID)
+	}
+	lock, err := data.GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkTon, addr.StringRaw(), "USDT", resp.ActualAmount)
+	if err != nil {
+		t.Fatalf("lookup TON USDT lock: %v", err)
+	}
+	if lock != "" {
+		t.Fatalf("TON USDT lock still exists after payment: %s", lock)
+	}
+}
+
+func TestTryProcessTonTransferSkipsTransfersBeforeOrderCreation(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := data.SetSetting("rate", "rate.forced_rate_list", `{"cny":{"ton":0.5}}`, "json"); err != nil {
+		t.Fatalf("set forced rate: %v", err)
+	}
+	addr := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	if _, err := data.AddWalletAddressWithNetwork(mdb.NetworkTon, addr.StringRaw()); err != nil {
+		t.Fatalf("add ton wallet: %v", err)
+	}
+	req := newCreateTransactionRequest("order_ton_old_transfer_1", 10)
+	req.Network = mdb.NetworkTon
+	req.Token = "TON"
+	resp, err := CreateTransaction(req, nil)
+	if err != nil {
+		t.Fatalf("create TON transaction: %v", err)
+	}
+	order, err := data.GetOrderInfoByTradeId(resp.TradeId)
+	if err != nil {
+		t.Fatalf("load order: %v", err)
+	}
+
+	TryProcessTonTransfer(&TonObservedTransfer{
+		ReceiveAddress: resp.ReceiveAddress,
+		Token:          mdb.ChainToken{BaseModel: mdb.BaseModel{ID: 1}, Network: mdb.NetworkTon, Symbol: "TON", Decimals: 9, Enabled: true},
+		RawAmount:      big.NewInt(5_000_000_000),
+		Amount:         resp.ActualAmount,
+		BlockTimeMs:    order.CreatedAt.TimestampMilli() - 1,
+		LT:             101,
+		TxHashHex:      strings.Repeat("2", 64),
+		BlockID:        TonCanonicalBlockTransactionID(addr.StringRaw(), 101, strings.Repeat("2", 64)),
+	})
+
+	order, err = data.GetOrderInfoByTradeId(resp.TradeId)
+	if err != nil {
+		t.Fatalf("reload order: %v", err)
+	}
+	if order.Status != mdb.StatusWaitPay {
+		t.Fatalf("order status = %d, want wait-pay", order.Status)
+	}
+	if order.BlockTransactionId != "" {
+		t.Fatalf("old transfer set block transaction id = %q", order.BlockTransactionId)
+	}
+}
+
+func TestTryProcessTonSubOrderPaysParentAndReleasesLocks(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := data.SetSetting("rate", "rate.forced_rate_list", `{"cny":{"usdt":0.1,"ton":0.5}}`, "json"); err != nil {
+		t.Fatalf("set forced rate: %v", err)
+	}
+	if _, err := data.AddWalletAddress("TTestTronAddressForTonSub"); err != nil {
+		t.Fatalf("add tron wallet: %v", err)
+	}
+	addr := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	if _, err := data.AddWalletAddressWithNetwork(mdb.NetworkTon, addr.StringRaw()); err != nil {
+		t.Fatalf("add ton wallet: %v", err)
+	}
+
+	parentReq := newCreateTransactionRequest("order_ton_sub_parent_1", 10)
+	parentReq.Network = mdb.NetworkTron
+	parentResp, err := CreateTransaction(parentReq, nil)
+	if err != nil {
+		t.Fatalf("create parent order: %v", err)
+	}
+	subResp, err := SwitchNetwork(&request.SwitchNetworkRequest{
+		TradeId: parentResp.TradeId,
+		Token:   "TON",
+		Network: mdb.NetworkTon,
+	})
+	if err != nil {
+		t.Fatalf("switch to TON: %v", err)
+	}
+
+	TryProcessTonTransfer(&TonObservedTransfer{
+		ReceiveAddress: subResp.ReceiveAddress,
+		Token:          mdb.ChainToken{BaseModel: mdb.BaseModel{ID: 1}, Network: mdb.NetworkTon, Symbol: "TON", Decimals: 9, Enabled: true},
+		RawAmount:      big.NewInt(5_000_000_000),
+		Amount:         subResp.ActualAmount,
+		BlockTimeMs:    time.Now().Add(time.Second).UnixMilli(),
+		LT:             102,
+		TxHashHex:      strings.Repeat("3", 64),
+		BlockID:        TonCanonicalBlockTransactionID(addr.StringRaw(), 102, strings.Repeat("3", 64)),
+	})
+
+	parent, err := data.GetOrderInfoByTradeId(parentResp.TradeId)
+	if err != nil {
+		t.Fatalf("reload parent order: %v", err)
+	}
+	if parent.Status != mdb.StatusPaySuccess {
+		t.Fatalf("parent status = %d, want paid", parent.Status)
+	}
+	sub, err := data.GetOrderInfoByTradeId(subResp.TradeId)
+	if err != nil {
+		t.Fatalf("reload sub order: %v", err)
+	}
+	if sub.Status != mdb.StatusPaySuccess {
+		t.Fatalf("sub status = %d, want paid", sub.Status)
+	}
+	parentLock, err := data.GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkTron, parentResp.ReceiveAddress, parentResp.Token, parentResp.ActualAmount)
+	if err != nil {
+		t.Fatalf("lookup parent lock: %v", err)
+	}
+	if parentLock != "" {
+		t.Fatalf("parent lock still exists: %s", parentLock)
+	}
+	subLock, err := data.GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkTon, addr.StringRaw(), "TON", subResp.ActualAmount)
+	if err != nil {
+		t.Fatalf("lookup sub lock: %v", err)
+	}
+	if subLock != "" {
+		t.Fatalf("TON sub-order lock still exists: %s", subLock)
+	}
+}
+
 func TestOrderProcessingMarksPaidAndReleasesLock(t *testing.T) {
 	cleanup := testutil.SetupTestDatabases(t)
 	defer cleanup()
@@ -799,7 +1488,6 @@ func TestOrderProcessingSubOrderExpiresSiblingsAndReleasesLocks(t *testing.T) {
 		t.Fatalf("create parent order: %v", err)
 	}
 
-	// Create two sub-orders on different networks.
 	subEthResp, err := SwitchNetwork(&request.SwitchNetworkRequest{
 		TradeId: parentResp.TradeId,
 		Token:   "usdt",
@@ -809,13 +1497,29 @@ func TestOrderProcessingSubOrderExpiresSiblingsAndReleasesLocks(t *testing.T) {
 		t.Fatalf("switch to ethereum sub-order: %v", err)
 	}
 
-	subBscResp, err := SwitchNetwork(&request.SwitchNetworkRequest{
+	bscTradeID := GenerateCode()
-		TradeId: parentResp.TradeId,
+	bscAddress := strings.ToLower("0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB")
-		Token:   "usdt",
+	subBsc := &mdb.Orders{
+		TradeId:         bscTradeID,
+		OrderId:         bscTradeID,
+		ParentTradeId:   parentResp.TradeId,
+		Amount:          parentResp.Amount,
+		Currency:        parentResp.Currency,
+		ActualAmount:    subEthResp.ActualAmount,
+		ReceiveAddress:  bscAddress,
+		Token:           "USDT",
 		Network:         mdb.NetworkBsc,
-	})
+		Status:          mdb.StatusWaitPay,
-	if err != nil {
+		IsSelected:      true,
-		t.Fatalf("switch to bsc sub-order: %v", err)
+		CallBackConfirm: mdb.CallBackConfirmOk,
+		PaymentType:     mdb.PaymentTypeGmpay,
+		PayProvider:     mdb.PaymentProviderOnChain,
+	}
+	if err := dao.Mdb.Create(subBsc).Error; err != nil {
+		t.Fatalf("seed bsc sibling sub-order: %v", err)
+	}
+	if err := data.LockTransaction(mdb.NetworkBsc, bscAddress, "USDT", bscTradeID, subBsc.ActualAmount, time.Hour); err != nil {
+		t.Fatalf("lock bsc sibling amount: %v", err)
 	}
 
 	// Pay the Ethereum sub-order.
@@ -832,12 +1536,12 @@ func TestOrderProcessingSubOrderExpiresSiblingsAndReleasesLocks(t *testing.T) {
 	}
 
 	// BSC sibling must be expired.
-	subBsc, err := data.GetOrderInfoByTradeId(subBscResp.TradeId)
+	reloadedBsc, err := data.GetOrderInfoByTradeId(subBsc.TradeId)
 	if err != nil {
 		t.Fatalf("reload bsc sub-order: %v", err)
 	}
-	if subBsc.Status != mdb.StatusExpired {
+	if reloadedBsc.Status != mdb.StatusExpired {
-		t.Fatalf("bsc sibling status = %d, want %d (expired)", subBsc.Status, mdb.StatusExpired)
+		t.Fatalf("bsc sibling status = %d, want %d (expired)", reloadedBsc.Status, mdb.StatusExpired)
 	}
 
 	// Parent runtime lock must be released.
@@ -852,7 +1556,7 @@ func TestOrderProcessingSubOrderExpiresSiblingsAndReleasesLocks(t *testing.T) {
 
 	// BSC sibling runtime lock must be released.
 	sibLock, err := data.GetTradeIdByWalletAddressAndAmountAndToken(
-		mdb.NetworkBsc, subBscResp.ReceiveAddress, subBscResp.Token, subBscResp.ActualAmount)
+		mdb.NetworkBsc, subBsc.ReceiveAddress, subBsc.Token, subBsc.ActualAmount)
 	if err != nil {
 		t.Fatalf("check bsc sibling runtime lock: %v", err)
 	}

src/model/service/pay_service.go

@@ -1,8 +1,8 @@
 package service
 
 import (
-	"github.com/GMWalletApp/epusdt/config"
 	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
 	"github.com/GMWalletApp/epusdt/model/response"
 	"github.com/GMWalletApp/epusdt/util/constant"
 )
@@ -20,19 +20,15 @@ func GetCheckoutCounterByTradeId(tradeId string) (*response.CheckoutCounterRespo
 	if orderInfo.ID <= 0 {
 		return nil, ErrOrder
 	}
-
+	resp := buildCheckoutResponse(orderInfo)
-	resp := &response.CheckoutCounterResponse{
+	if orderInfo.PayProvider == mdb.PaymentProviderOkPay {
-		TradeId:        orderInfo.TradeId,
+		providerRow, rowErr := data.GetProviderOrderByTradeIDAndProvider(orderInfo.TradeId, mdb.PaymentProviderOkPay)
-		Amount:         orderInfo.Amount,
+		if rowErr != nil {
-		ActualAmount:   orderInfo.ActualAmount,
+			return nil, rowErr
-		Token:          orderInfo.Token,
+		}
-		Currency:       orderInfo.Currency,
+		if providerRow.ID > 0 {
-		ReceiveAddress: orderInfo.ReceiveAddress,
+			resp.PaymentUrl = providerRow.PayURL
-		Network:        orderInfo.Network,
+		}
-		ExpirationTime: orderInfo.CreatedAt.AddMinutes(config.GetOrderExpirationTime()).TimestampMilli(),
-		RedirectUrl:    orderInfo.RedirectUrl,
-		CreatedAt:      orderInfo.CreatedAt.TimestampMilli(),
-		IsSelected:     orderInfo.IsSelected,
 	}
 	return resp, nil
 }

src/model/service/payment_asset.go

@@ -0,0 +1,32 @@
+package service
+
+import (
+	"strings"
+
+	"github.com/GMWalletApp/epusdt/model/mdb"
+)
+
+func ChainTokenReadyForPayment(token mdb.ChainToken) bool {
+	if strings.TrimSpace(token.Symbol) == "" {
+		return false
+	}
+	if chainTokenRequiresAssetID(token) && strings.TrimSpace(token.ContractAddress) == "" {
+		return false
+	}
+	return true
+}
+
+func chainTokenRequiresAssetID(token mdb.ChainToken) bool {
+	network := strings.ToLower(strings.TrimSpace(token.Network))
+	symbol := strings.ToUpper(strings.TrimSpace(token.Symbol))
+	switch network {
+	case mdb.NetworkTron:
+		return symbol != "TRX"
+	case mdb.NetworkSolana:
+		return symbol != "SOL"
+	case mdb.NetworkTon:
+		return symbol != TonNativeSymbol
+	default:
+		return true
+	}
+}

src/model/service/task_service_test.go

@@ -12,8 +12,24 @@ import (
 	"github.com/GMWalletApp/epusdt/model/mdb"
 	"github.com/GMWalletApp/epusdt/notify"
 	"github.com/ethereum/go-ethereum/common"
+	"gorm.io/gorm/clause"
 )
 
+func upsertTaskServiceTestChainToken(t *testing.T, token mdb.ChainToken) {
+	t.Helper()
+	if err := dao.Mdb.Clauses(clause.OnConflict{
+		Columns: []clause.Column{{Name: "network"}, {Name: "symbol"}},
+		DoUpdates: clause.AssignmentColumns([]string{
+			"contract_address",
+			"decimals",
+			"enabled",
+			"min_amount",
+		}),
+	}).Create(&token).Error; err != nil {
+		t.Fatalf("seed chain token: %v", err)
+	}
+}
+
 func TestSendPaymentNotificationUsesLatestOrderUpdatedAt(t *testing.T) {
 	cleanup := testutil.SetupTestDatabases(t)
 	defer cleanup()
@@ -158,15 +174,13 @@ func TestTryProcessEvmERC20TransferSkipsTransfersBeforeOrderCreation(t *testing.
 	contract := common.HexToAddress("0x3333333333333333333333333333333333333333")
 	receiveAddress := common.HexToAddress("0x4444444444444444444444444444444444444444")
 
-	if err := dao.Mdb.Create(&mdb.ChainToken{
+	upsertTaskServiceTestChainToken(t, mdb.ChainToken{
 		Network:         mdb.NetworkEthereum,
 		Symbol:          tokenSym,
 		ContractAddress: contract.Hex(),
 		Decimals:        6,
 		Enabled:         true,
-	}).Error; err != nil {
+	})
-		t.Fatalf("seed chain token: %v", err)
-	}
 
 	order := &mdb.Orders{
 		TradeId:        tradeID,

src/model/service/ton_lite_client.go

@@ -0,0 +1,37 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/xssnick/tonutils-go/liteclient"
+	"github.com/xssnick/tonutils-go/ton"
+)
+
+// ConnectTonLiteAPI builds a tonutils-go API client from a liteserver global
+// config URL. Scanner and manual verification use this same connection setup.
+func ConnectTonLiteAPI(ctx context.Context, configURL string, requestTimeout time.Duration, reconnectLimit int) (ton.APIClientWrapped, func(), error) {
+	configURL = strings.TrimSpace(configURL)
+	if configURL == "" {
+		return nil, func() {}, fmt.Errorf("ton lite config url is empty")
+	}
+	if reconnectLimit <= 0 {
+		reconnectLimit = 3
+	}
+	cfg, err := liteclient.GetConfigFromUrl(ctx, configURL)
+	if err != nil {
+		return nil, func() {}, err
+	}
+	pool := liteclient.NewConnectionPool()
+	pool.SetOnDisconnect(pool.DefaultReconnect(3*time.Second, reconnectLimit))
+	if err = pool.AddConnectionsFromConfig(ctx, cfg); err != nil {
+		pool.Stop()
+		return nil, func() {}, err
+	}
+	base := ton.NewAPIClient(pool, ton.ProofCheckPolicyFast)
+	base.SetTrustedBlockFromConfig(cfg)
+	api := base.WithRetry(2).WithTimeout(requestTimeout).WithLSInfoInErrors()
+	return api, pool.Stop, nil
+}

src/model/service/ton_task.go

@@ -0,0 +1,262 @@
+package service
+
+import (
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"math/big"
+	"strings"
+
+	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	"github.com/GMWalletApp/epusdt/model/request"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
+	"github.com/GMWalletApp/epusdt/util/constant"
+	"github.com/GMWalletApp/epusdt/util/log"
+	"github.com/GMWalletApp/epusdt/util/math"
+	"github.com/shopspring/decimal"
+	"github.com/xssnick/tonutils-go/address"
+	"github.com/xssnick/tonutils-go/tlb"
+	"github.com/xssnick/tonutils-go/ton/jetton"
+	"github.com/xssnick/tonutils-go/tvm/cell"
+)
+
+const (
+	TonNativeSymbol               = "TON"
+	TonTransferNotificationOpcode = 0x7362d09c
+)
+
+type TonObservedTransfer struct {
+	ReceiveAddress string
+	Token          mdb.ChainToken
+	RawAmount      *big.Int
+	Amount         float64
+	BlockTimeMs    int64
+	LT             uint64
+	TxHashHex      string
+	BlockID        string
+	SenderAddress  string
+	JettonWallet   string
+}
+
+func TonCanonicalBlockTransactionID(receiveRaw string, lt uint64, txHashHex string) string {
+	return fmt.Sprintf("ton:%s:%d:%s", strings.ToLower(strings.TrimSpace(receiveRaw)), lt, strings.ToLower(strings.TrimSpace(txHashHex)))
+}
+
+func ParseTonInboundTransfer(tx *tlb.Transaction, receive *address.Address, nativeToken *mdb.ChainToken, jettonWalletTokens map[string]mdb.ChainToken) (*TonObservedTransfer, error) {
+	if tx == nil || receive == nil || tx.IO.In == nil || tx.IO.In.MsgType != tlb.MsgTypeInternal {
+		return nil, nil
+	}
+	if isTonTransactionBounced(tx) {
+		return nil, nil
+	}
+	in := tx.IO.In.AsInternal()
+	if in == nil || in.DstAddr == nil || !in.DstAddr.Equals(receive) {
+		return nil, nil
+	}
+
+	receiveRaw := addressutil.TonRawAddressObjectKey(receive)
+	txHashHex := hex.EncodeToString(tx.Hash)
+	blockID := TonCanonicalBlockTransactionID(receiveRaw, tx.LT, txHashHex)
+	blockTimeMs := int64(tx.Now) * 1000
+	if in.SrcAddr != nil {
+		srcRaw := addressutil.TonRawAddressObjectKey(in.SrcAddr)
+		if token, ok := jettonWalletTokens[srcRaw]; ok {
+			transfer, err := parseTonJettonTransferNotification(in)
+			if err != nil {
+				return nil, nil
+			}
+			amount := tonRawAmountToFloat(transfer.Amount.Nano(), token.Decimals)
+			if amount <= 0 {
+				return nil, nil
+			}
+			if token.MinAmount > 0 && amount < token.MinAmount {
+				return nil, nil
+			}
+			return &TonObservedTransfer{
+				ReceiveAddress: addressutil.NormalizeTonAddressObject(receive),
+				Token:          token,
+				RawAmount:      transfer.Amount.Nano(),
+				Amount:         amount,
+				BlockTimeMs:    blockTimeMs,
+				LT:             tx.LT,
+				TxHashHex:      txHashHex,
+				BlockID:        blockID,
+				SenderAddress:  addressutil.NormalizeTonAddressObject(transfer.Sender),
+				JettonWallet:   addressutil.NormalizeTonAddressObject(in.SrcAddr),
+			}, nil
+		}
+	}
+
+	if tonPayloadIsTransferNotification(in.Body) {
+		return nil, nil
+	}
+	if nativeToken == nil || nativeToken.ID == 0 {
+		return nil, nil
+	}
+	rawNano := in.Amount.Nano()
+	if rawNano == nil || rawNano.Sign() <= 0 {
+		return nil, nil
+	}
+	amount := tonRawAmountToFloat(rawNano, nativeToken.Decimals)
+	if amount <= 0 {
+		return nil, nil
+	}
+	if nativeToken.MinAmount > 0 && amount < nativeToken.MinAmount {
+		return nil, nil
+	}
+	return &TonObservedTransfer{
+		ReceiveAddress: addressutil.NormalizeTonAddressObject(receive),
+		Token:          *nativeToken,
+		RawAmount:      rawNano,
+		Amount:         amount,
+		BlockTimeMs:    blockTimeMs,
+		LT:             tx.LT,
+		TxHashHex:      txHashHex,
+		BlockID:        blockID,
+	}, nil
+}
+
+func TryProcessTonTransfer(transfer *TonObservedTransfer) {
+	if transfer == nil {
+		return
+	}
+	tokenSym := strings.ToUpper(strings.TrimSpace(transfer.Token.Symbol))
+	defer func() {
+		if err := recover(); err != nil {
+			log.Sugar.Errorf("[TON-%s][%s] TryProcessTonTransfer panic: %v", tokenSym, transfer.ReceiveAddress, err)
+		}
+	}()
+
+	receive := strings.TrimSpace(transfer.ReceiveAddress)
+	if tokenSym == "" || receive == "" || transfer.Amount <= 0 || transfer.BlockID == "" {
+		return
+	}
+	log.Sugar.Infof("[TON-%s][%s] observed transfer tx=%s lt=%d amount=%.6f", tokenSym, receive, transfer.BlockID, transfer.LT, transfer.Amount)
+
+	tradeID, err := data.GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkTon, receive, tokenSym, transfer.Amount)
+	if err != nil {
+		log.Sugar.Warnf("[TON-%s][%s] lock lookup: %v", tokenSym, receive, err)
+		return
+	}
+	if tradeID == "" {
+		log.Sugar.Infof("[TON-%s][%s] skip unmatched transfer tx=%s amount=%.6f", tokenSym, receive, transfer.BlockID, transfer.Amount)
+		return
+	}
+
+	order, err := data.GetOrderInfoByTradeId(tradeID)
+	if err != nil {
+		log.Sugar.Warnf("[TON-%s][%s] load order: %v", tokenSym, receive, err)
+		return
+	}
+	if strings.ToLower(strings.TrimSpace(order.Network)) != mdb.NetworkTon {
+		log.Sugar.Warnf("[TON-%s][%s] skip trade_id=%s network=%q", tokenSym, receive, tradeID, order.Network)
+		return
+	}
+	if strings.ToUpper(strings.TrimSpace(order.Token)) != tokenSym {
+		log.Sugar.Warnf("[TON-%s][%s] skip trade_id=%s token mismatch order=%s", tokenSym, receive, tradeID, order.Token)
+		return
+	}
+	if !tonOrderAddressMatches(order.ReceiveAddress, receive) {
+		log.Sugar.Warnf("[TON-%s][%s] skip trade_id=%s receive address mismatch order=%s", tokenSym, receive, tradeID, order.ReceiveAddress)
+		return
+	}
+	if transfer.BlockTimeMs > 0 && transfer.BlockTimeMs < order.CreatedAt.TimestampMilli() {
+		log.Sugar.Warnf("[TON-%s][%s] skip tx %s because block time %d is before order create time %d", tokenSym, receive, transfer.BlockID, transfer.BlockTimeMs, order.CreatedAt.TimestampMilli())
+		return
+	}
+
+	req := &request.OrderProcessingRequest{
+		ReceiveAddress:     order.ReceiveAddress,
+		Token:              tokenSym,
+		Network:            mdb.NetworkTon,
+		TradeId:            tradeID,
+		Amount:             transfer.Amount,
+		BlockTransactionId: transfer.BlockID,
+	}
+	err = OrderProcessing(req)
+	if err != nil {
+		if errors.Is(err, constant.OrderBlockAlreadyProcess) || errors.Is(err, constant.OrderStatusConflict) {
+			log.Sugar.Infof("[TON-%s][%s] skip resolved transfer trade_id=%s tx=%s err=%v", tokenSym, receive, tradeID, transfer.BlockID, err)
+			return
+		}
+		log.Sugar.Errorf("[TON-%s][%s] OrderProcessing trade_id=%s tx=%s: %v", tokenSym, receive, tradeID, transfer.BlockID, err)
+		return
+	}
+
+	sendPaymentNotification(order)
+	log.Sugar.Infof("[TON-%s][%s] payment processed trade_id=%s tx=%s", tokenSym, receive, tradeID, transfer.BlockID)
+}
+
+func tonOrderAddressMatches(a, b string) bool {
+	ar, errA := addressutil.TonRawAddressKey(a)
+	br, errB := addressutil.TonRawAddressKey(b)
+	return errA == nil && errB == nil && ar == br
+}
+
+func tonRawAmountToFloat(rawAmount *big.Int, decimals int) float64 {
+	if rawAmount == nil || rawAmount.Sign() <= 0 {
+		return 0
+	}
+	if decimals < 0 {
+		decimals = 0
+	}
+	amount := decimal.NewFromBigInt(rawAmount, -int32(decimals))
+	return math.MustParsePrecFloat64(amount.InexactFloat64(), data.MaxAmountPrecision)
+}
+
+func parseTonJettonTransferNotification(in *tlb.InternalMessage) (*jetton.TransferNotification, error) {
+	if in == nil || in.Body == nil {
+		return nil, fmt.Errorf("missing jetton transfer notification body")
+	}
+	var transfer jetton.TransferNotification
+	if err := tlb.LoadFromCell(&transfer, in.Body.BeginParse()); err != nil {
+		return nil, err
+	}
+	return &transfer, nil
+}
+
+func tonPayloadIsTransferNotification(body *cell.Cell) bool {
+	if body == nil {
+		return false
+	}
+	op, err := body.BeginParse().LoadUInt(32)
+	return err == nil && op == TonTransferNotificationOpcode
+}
+
+func isTonTransactionBounced(tx *tlb.Transaction) bool {
+	if tx == nil {
+		return false
+	}
+	if dsc, ok := tx.Description.(tlb.TransactionDescriptionOrdinary); ok && dsc.BouncePhase != nil {
+		if _, ok = dsc.BouncePhase.Phase.(tlb.BouncePhaseOk); ok {
+			return true
+		}
+	}
+	return false
+}
+
+func EnsureTonTransferMatchesOrder(order *mdb.Orders, transfer *TonObservedTransfer) error {
+	if order == nil || order.ID == 0 {
+		return fmt.Errorf("order not found")
+	}
+	if transfer == nil {
+		return fmt.Errorf("matching ton transfer to order address not found")
+	}
+	if strings.ToLower(strings.TrimSpace(order.Network)) != mdb.NetworkTon {
+		return fmt.Errorf("order network mismatch")
+	}
+	if !strings.EqualFold(order.Token, transfer.Token.Symbol) {
+		return fmt.Errorf("transaction token mismatch")
+	}
+	if !tonOrderAddressMatches(order.ReceiveAddress, transfer.ReceiveAddress) {
+		return fmt.Errorf("transaction recipient mismatch")
+	}
+	if transfer.BlockTimeMs <= 0 || transfer.BlockTimeMs < order.CreatedAt.TimestampMilli() {
+		return fmt.Errorf("transaction predates the order")
+	}
+	if !amountMatchesRaw(order.ActualAmount, transfer.RawAmount, transfer.Token.Decimals) {
+		return fmt.Errorf("transaction amount mismatch")
+	}
+	return nil
+}

src/model/service/ton_task_test.go

@@ -0,0 +1,173 @@
+package service
+
+import (
+	"bytes"
+	"math/big"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
+	"github.com/xssnick/tonutils-go/address"
+	"github.com/xssnick/tonutils-go/tlb"
+	"github.com/xssnick/tonutils-go/ton/jetton"
+	"github.com/xssnick/tonutils-go/tvm/cell"
+)
+
+func tonTestInboundTx(t *testing.T, src, dst *address.Address, amount tlb.Coins, body *cell.Cell) *tlb.Transaction {
+	t.Helper()
+	return &tlb.Transaction{
+		LT:   123,
+		Now:  uint32(time.Now().Unix()),
+		Hash: bytes.Repeat([]byte{0x11}, 32),
+		IO: struct {
+			In  *tlb.Message      `tlb:"maybe ^"`
+			Out *tlb.MessagesList `tlb:"maybe ^"`
+		}{
+			In: &tlb.Message{
+				MsgType: tlb.MsgTypeInternal,
+				Msg: &tlb.InternalMessage{
+					SrcAddr: src,
+					DstAddr: dst,
+					Amount:  amount,
+					Body:    body,
+				},
+			},
+		},
+	}
+}
+
+func TestParseTonInboundTransferNativeTON(t *testing.T) {
+	receive := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	sender := address.NewAddress(0, 0, bytes.Repeat([]byte{0x22}, 32)).Bounce(false).Testnet(false)
+	native := &mdb.ChainToken{BaseModel: mdb.BaseModel{ID: 1}, Network: mdb.NetworkTon, Symbol: "TON", Decimals: 9, Enabled: true}
+
+	tx := tonTestInboundTx(t, sender, receive, tlb.MustFromTON("1.23"), cell.BeginCell().EndCell())
+	transfer, err := ParseTonInboundTransfer(tx, receive, native, nil)
+	if err != nil {
+		t.Fatalf("ParseTonInboundTransfer(): %v", err)
+	}
+	if transfer == nil {
+		t.Fatal("expected native TON transfer")
+	}
+	if transfer.Token.Symbol != "TON" {
+		t.Fatalf("token = %q, want TON", transfer.Token.Symbol)
+	}
+	if transfer.Amount != 1.23 {
+		t.Fatalf("amount = %v, want 1.23", transfer.Amount)
+	}
+	if transfer.ReceiveAddress != addressutil.NormalizeTonAddressObject(receive) {
+		t.Fatalf("receive address = %q", transfer.ReceiveAddress)
+	}
+	if !strings.HasPrefix(transfer.BlockID, "ton:"+addressutil.TonRawAddressObjectKey(receive)+":123:") {
+		t.Fatalf("block id = %q, want canonical TON prefix", transfer.BlockID)
+	}
+}
+
+func TestParseTonInboundTransferJettonNotification(t *testing.T) {
+	receive := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	sender := address.NewAddress(0, 0, bytes.Repeat([]byte{0x33}, 32)).Bounce(false).Testnet(false)
+	jettonWallet := address.NewAddress(0, 0, bytes.Repeat([]byte{0x44}, 32)).Bounce(false).Testnet(false)
+	native := &mdb.ChainToken{BaseModel: mdb.BaseModel{ID: 1}, Network: mdb.NetworkTon, Symbol: "TON", Decimals: 9, Enabled: true}
+	usdt := mdb.ChainToken{BaseModel: mdb.BaseModel{ID: 2}, Network: mdb.NetworkTon, Symbol: "USDT", Decimals: 6, Enabled: true}
+
+	body, err := tlb.ToCell(jetton.TransferNotification{
+		QueryID:        7,
+		Amount:         tlb.MustFromNano(big.NewInt(1230000), 6),
+		Sender:         sender,
+		ForwardPayload: cell.BeginCell().EndCell(),
+	})
+	if err != nil {
+		t.Fatalf("build jetton notification body: %v", err)
+	}
+
+	tx := tonTestInboundTx(t, jettonWallet, receive, tlb.FromNanoTONU(1), body)
+	transfer, err := ParseTonInboundTransfer(tx, receive, native, map[string]mdb.ChainToken{
+		addressutil.TonRawAddressObjectKey(jettonWallet): usdt,
+	})
+	if err != nil {
+		t.Fatalf("ParseTonInboundTransfer(): %v", err)
+	}
+	if transfer == nil {
+		t.Fatal("expected USDT jetton transfer")
+	}
+	if transfer.Token.Symbol != "USDT" {
+		t.Fatalf("token = %q, want USDT", transfer.Token.Symbol)
+	}
+	if transfer.Amount != 1.23 {
+		t.Fatalf("amount = %v, want 1.23", transfer.Amount)
+	}
+	if transfer.SenderAddress != addressutil.NormalizeTonAddressObject(sender) {
+		t.Fatalf("sender address = %q", transfer.SenderAddress)
+	}
+	if transfer.JettonWallet != addressutil.NormalizeTonAddressObject(jettonWallet) {
+		t.Fatalf("jetton wallet = %q", transfer.JettonWallet)
+	}
+}
+
+func TestParseTonInboundTransferJettonNotificationWithNoGasComputeSkip(t *testing.T) {
+	receive := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	sender := address.NewAddress(0, 0, bytes.Repeat([]byte{0x33}, 32)).Bounce(false).Testnet(false)
+	jettonWallet := address.NewAddress(0, 0, bytes.Repeat([]byte{0x44}, 32)).Bounce(false).Testnet(false)
+	usdt := mdb.ChainToken{BaseModel: mdb.BaseModel{ID: 2}, Network: mdb.NetworkTon, Symbol: "USDT", Decimals: 6, Enabled: true}
+
+	body, err := tlb.ToCell(jetton.TransferNotification{
+		QueryID:        7,
+		Amount:         tlb.MustFromNano(big.NewInt(150000), 6),
+		Sender:         sender,
+		ForwardPayload: cell.BeginCell().EndCell(),
+	})
+	if err != nil {
+		t.Fatalf("build jetton notification body: %v", err)
+	}
+
+	tx := tonTestInboundTx(t, jettonWallet, receive, tlb.FromNanoTONU(1), body)
+	tx.Description = tlb.TransactionDescriptionOrdinary{
+		ComputePhase: tlb.ComputePhase{Phase: tlb.ComputePhaseSkipped{
+			Reason: tlb.ComputeSkipReason{Type: tlb.ComputeSkipReasonNoGas},
+		}},
+		Aborted: true,
+	}
+	transfer, err := ParseTonInboundTransfer(tx, receive, nil, map[string]mdb.ChainToken{
+		addressutil.TonRawAddressObjectKey(jettonWallet): usdt,
+	})
+	if err != nil {
+		t.Fatalf("ParseTonInboundTransfer(): %v", err)
+	}
+	if transfer == nil {
+		t.Fatal("expected no-gas jetton notification to be accepted")
+	}
+	if transfer.Token.Symbol != "USDT" {
+		t.Fatalf("token = %q, want USDT", transfer.Token.Symbol)
+	}
+	if transfer.Amount != 0.15 {
+		t.Fatalf("amount = %v, want 0.15", transfer.Amount)
+	}
+}
+
+func TestParseTonInboundTransferDoesNotCountUntrustedJettonNotificationAsTON(t *testing.T) {
+	receive := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	sender := address.NewAddress(0, 0, bytes.Repeat([]byte{0x33}, 32)).Bounce(false).Testnet(false)
+	untrustedJettonWallet := address.NewAddress(0, 0, bytes.Repeat([]byte{0x55}, 32)).Bounce(false).Testnet(false)
+	native := &mdb.ChainToken{BaseModel: mdb.BaseModel{ID: 1}, Network: mdb.NetworkTon, Symbol: "TON", Decimals: 9, Enabled: true}
+
+	body, err := tlb.ToCell(jetton.TransferNotification{
+		QueryID:        7,
+		Amount:         tlb.MustFromNano(big.NewInt(1230000), 6),
+		Sender:         sender,
+		ForwardPayload: cell.BeginCell().EndCell(),
+	})
+	if err != nil {
+		t.Fatalf("build jetton notification body: %v", err)
+	}
+
+	tx := tonTestInboundTx(t, untrustedJettonWallet, receive, tlb.FromNanoTONU(1), body)
+	transfer, err := ParseTonInboundTransfer(tx, receive, native, nil)
+	if err != nil {
+		t.Fatalf("ParseTonInboundTransfer(): %v", err)
+	}
+	if transfer != nil {
+		t.Fatalf("untrusted jetton notification produced transfer: %#v", transfer)
+	}
+}

src/mq/worker.go

@@ -2,9 +2,7 @@ package mq
 
 import (
 	"errors"
-	"fmt"
 	"net/http"
-	"strconv"
 	"strings"
 	"time"
 
@@ -13,6 +11,7 @@ import (
 	"github.com/GMWalletApp/epusdt/model/data"
 	"github.com/GMWalletApp/epusdt/model/mdb"
 	"github.com/GMWalletApp/epusdt/model/response"
+	"github.com/GMWalletApp/epusdt/model/service"
 	"github.com/GMWalletApp/epusdt/util/http_client"
 	"github.com/GMWalletApp/epusdt/util/log"
 	"github.com/GMWalletApp/epusdt/util/sign"
@@ -25,18 +24,12 @@ import (
 // other secret would produce a signature the merchant can't verify.
 // The admin can resend the callback after fixing the key.
 func resolveOrderApiKey(order *mdb.Orders) (*mdb.ApiKey, error) {
-	if order.ApiKeyID == 0 {
+	row, err := service.ResolveOrderApiKey(order)
-		return nil, fmt.Errorf("order trade_id=%s has no api_key_id", order.TradeId)
+	if err != nil || row == nil || row.ID == 0 {
-	}
-	row, err := data.GetApiKeyByID(order.ApiKeyID)
 		if err != nil {
-		return nil, fmt.Errorf("lookup api_key_id=%d: %w", order.ApiKeyID, err)
+			return nil, err
 		}
-	if row.ID == 0 {
+		return nil, errors.New("api key unavailable")
-		return nil, fmt.Errorf("api_key_id=%d not found (deleted?)", order.ApiKeyID)
-	}
-	if row.Status != mdb.ApiKeyStatusEnable {
-		return nil, fmt.Errorf("api_key_id=%d is disabled", order.ApiKeyID)
 	}
 	return row, nil
 }
@@ -48,10 +41,12 @@ const sqliteBusyRetryAttempts = 3
 type expirableOrder struct {
 	ID             uint64  `gorm:"column:id"`
 	TradeId        string  `gorm:"column:trade_id"`
+	Status         int     `gorm:"column:status"`
 	Network        string  `gorm:"column:network"`
 	ReceiveAddress string  `gorm:"column:receive_address"`
 	Token          string  `gorm:"column:token"`
 	ActualAmount   float64 `gorm:"column:actual_amount"`
+	PayProvider    string  `gorm:"column:pay_provider"`
 }
 
 func runOrderExpirationLoop() {
@@ -91,8 +86,8 @@ func processExpiredOrders() {
 		var orders []expirableOrder
 		err := withSQLiteBusyRetry(func() error {
 			return dao.Mdb.Model(&mdb.Orders{}).
-				Select("id", "trade_id", "network", "receive_address", "token", "actual_amount").
+				Select("id", "trade_id", "status", "network", "receive_address", "token", "actual_amount", "pay_provider").
-				Where("status = ?", mdb.StatusWaitPay).
+				Where("status IN ?", []int{mdb.StatusWaitPay, mdb.StatusWaitSelect}).
 				Where("created_at <= ?", expirationCutoff).
 				Order("id asc").
 				Limit(batchSize).
@@ -115,6 +110,17 @@ func processExpiredOrders() {
 			if !expired {
 				continue
 			}
+			// StatusWaitSelect placeholders have not reserved a wallet or
+			// amount yet, so there is no transaction lock to release.
+			if order.Status == mdb.StatusWaitSelect {
+				continue
+			}
+			if strings.TrimSpace(order.PayProvider) != "" && order.PayProvider != mdb.PaymentProviderOnChain {
+				continue
+			}
+			if strings.TrimSpace(order.Network) == "" || strings.TrimSpace(order.ReceiveAddress) == "" || strings.TrimSpace(order.Token) == "" || order.ActualAmount <= 0 {
+				continue
+			}
 			if err = data.UnLockTransaction(order.Network, order.ReceiveAddress, order.Token, order.ActualAmount); err != nil {
 				log.Sugar.Warnf("[mq] release expired transaction lock failed, trade_id=%s, err=%v", order.TradeId, err)
 			}
@@ -192,40 +198,13 @@ func sendOrderCallback(order *mdb.Orders) error {
 		return errors.New("no api key row available for callback")
 	}
 
-	switch order.PaymentType {
+	switch {
-	case mdb.PaymentTypeEpay:
+	case strings.EqualFold(order.PaymentType, mdb.PaymentTypeEpay):
-		// EPAY uses pid (integer) and secret_key as "key".
+		formData, err := service.BuildEPayResultParams(order, apiKeyRow)
-		pidInt, convErr := strconv.Atoi(apiKeyRow.Pid)
-		if convErr != nil {
-			return fmt.Errorf("epay pid not numeric: %s", apiKeyRow.Pid)
-		}
-		notifyData := response.OrderNotifyResponseEpay{
-			PID:         pidInt,
-			TradeNo:     order.TradeId,
-			OutTradeNo:  order.OrderId,
-			Type:        "alipay",
-			Name:        order.Name,
-			Money:       fmt.Sprintf("%.4f", order.Amount),
-			TradeStatus: "TRADE_SUCCESS",
-		}
-
-		signstr2, err := sign.Get(notifyData, apiKeyRow.SecretKey)
 		if err != nil {
 			return err
 		}
 
-		formData := map[string]string{
-			"pid":          fmt.Sprintf("%d", notifyData.PID),
-			"trade_no":     notifyData.TradeNo,
-			"out_trade_no": notifyData.OutTradeNo,
-			"type":         notifyData.Type,
-			"name":         notifyData.Name,
-			"money":        notifyData.Money,
-			"trade_status": notifyData.TradeStatus,
-			"sign":         signstr2,
-			"sign_type":    "MD5",
-		}
-
 		epayResp, err := http_client.GetHttpClient().R().SetQueryParams(formData).Get(order.NotifyUrl)
 		if err != nil {
 			return err

src/mq/worker_test.go

@@ -62,6 +62,21 @@ func TestProcessExpiredOrdersExpiresWaitingOrdersAndReleasesLocks(t *testing.T)
 		t.Fatalf("lock recent order: %v", err)
 	}
 
+	placeholder := &mdb.Orders{
+		TradeId:   "trade_wait_select_expired",
+		OrderId:   "order_wait_select_expired",
+		Amount:    1,
+		Currency:  "CNY",
+		Status:    mdb.StatusWaitSelect,
+		NotifyUrl: "https://merchant.example/callback",
+	}
+	if err := dao.Mdb.Create(placeholder).Error; err != nil {
+		t.Fatalf("create placeholder order: %v", err)
+	}
+	if err := dao.Mdb.Model(placeholder).UpdateColumn("created_at", time.Now().Add(-20*time.Minute)).Error; err != nil {
+		t.Fatalf("age placeholder order: %v", err)
+	}
+
 	processExpiredOrders()
 
 	expired, err := data.GetOrderInfoByTradeId(order.TradeId)
@@ -93,6 +108,14 @@ func TestProcessExpiredOrdersExpiresWaitingOrdersAndReleasesLocks(t *testing.T)
 	if lockTradeID != recentOrder.TradeId {
 		t.Fatalf("recent order lock = %s, want %s", lockTradeID, recentOrder.TradeId)
 	}
+
+	expiredPlaceholder, err := data.GetOrderInfoByTradeId(placeholder.TradeId)
+	if err != nil {
+		t.Fatalf("reload expired placeholder: %v", err)
+	}
+	if expiredPlaceholder.Status != mdb.StatusExpired {
+		t.Fatalf("placeholder status = %d, want %d", expiredPlaceholder.Status, mdb.StatusExpired)
+	}
 }
 
 func TestProcessExpiredOrdersKeepsPaidOrdersPaid(t *testing.T) {
@@ -295,7 +318,7 @@ func TestDispatchPendingCallbacksEpayRequiresAck(t *testing.T) {
 		BlockTransactionId: "block_callback_epay_fail",
 		CallbackNum:        0,
 		CallBackConfirm:    mdb.CallBackConfirmNo,
-		PaymentType:        mdb.PaymentTypeEpay,
+		PaymentType:        "epay",
 		ApiKeyID:           epayKey.ID,
 	}
 	if err := dao.Mdb.Create(order).Error; err != nil {
@@ -349,7 +372,7 @@ func TestDispatchPendingCallbacksEpayAcceptsTrimmedOk(t *testing.T) {
 		BlockTransactionId: "block_callback_epay_ok",
 		CallbackNum:        0,
 		CallBackConfirm:    mdb.CallBackConfirmNo,
-		PaymentType:        mdb.PaymentTypeEpay,
+		PaymentType:        "epay",
 		ApiKeyID:           epayKey.ID,
 	}
 	if err := dao.Mdb.Create(order).Error; err != nil {
@@ -550,7 +573,7 @@ func TestSendOrderCallbackEpayUsesApiKeySecretByPid(t *testing.T) {
 		Status:             mdb.StatusPaySuccess,
 		NotifyUrl:          server.URL,
 		BlockTransactionId: "block_epay_sign",
-		PaymentType:        mdb.PaymentTypeEpay,
+		PaymentType:        "epay",
 		ApiKeyID:           key.ID,
 	}
 

src/route/admin_router_test.go

@@ -18,6 +18,7 @@ import (
 	"github.com/GMWalletApp/epusdt/model/mdb"
 	"github.com/GMWalletApp/epusdt/model/service"
 	"github.com/GMWalletApp/epusdt/util/constant"
+	appLog "github.com/GMWalletApp/epusdt/util/log"
 	"github.com/labstack/echo/v4"
 )
 
@@ -762,6 +763,34 @@ func TestAdminOrders_CloseNotFound(t *testing.T) {
 	}
 }
 
+func TestAdminOrders_CloseWaitSelectOrder(t *testing.T) {
+	e, token := setupAdminTestEnv(t)
+	order := &mdb.Orders{
+		TradeId:     "trade-admin-close-wait-select",
+		OrderId:     "order-admin-close-wait-select",
+		Amount:      10,
+		Currency:    "CNY",
+		Status:      mdb.StatusWaitSelect,
+		NotifyUrl:   "https://merchant.example/notify",
+		PayProvider: mdb.PaymentProviderOnChain,
+	}
+	if err := dao.Mdb.Create(order).Error; err != nil {
+		t.Fatalf("create wait-select order: %v", err)
+	}
+
+	rec := doPostAdmin(e, "/admin/api/v1/orders/"+order.TradeId+"/close", nil, token)
+	t.Logf("CloseOrder wait-select: status=%d body=%s", rec.Code, rec.Body.String())
+	assertOK(t, rec)
+
+	reloaded, err := data.GetOrderInfoByTradeId(order.TradeId)
+	if err != nil {
+		t.Fatalf("reload order: %v", err)
+	}
+	if reloaded.Status != mdb.StatusExpired {
+		t.Fatalf("status = %d, want %d", reloaded.Status, mdb.StatusExpired)
+	}
+}
+
 // TestAdminOrders_MarkPaidNotFound verifies mark-paid on non-existent order.
 func TestAdminOrders_MarkPaidNotFound(t *testing.T) {
 	e, token := setupAdminTestEnv(t)
@@ -1441,6 +1470,90 @@ func TestAdminSettings_AmountPrecisionValidationAndListing(t *testing.T) {
 	}
 }
 
+func TestAdminSettings_LogLevelValidationRuntimeUpdateAndReset(t *testing.T) {
+	e, token := setupAdminTestEnv(t)
+	oldLevel := appLog.CurrentLevel()
+	t.Cleanup(func() {
+		_ = appLog.SetLevel(oldLevel)
+	})
+	if err := appLog.SetLevel(mdb.SettingDefaultSystemLogLevel); err != nil {
+		t.Fatalf("reset log level: %v", err)
+	}
+
+	rec := doPutAdmin(e, "/admin/api/v1/settings", map[string]interface{}{
+		"items": []map[string]interface{}{
+			{"group": "system", "key": mdb.SettingKeySystemLogLevel, "value": " DEBUG ", "type": "string"},
+		},
+	}, token)
+	resp := assertOK(t, rec)
+	results, ok := resp["data"].([]interface{})
+	if !ok || len(results) != 1 {
+		t.Fatalf("expected one result, got %T %v", resp["data"], resp["data"])
+	}
+	result, _ := results[0].(map[string]interface{})
+	if result["ok"] != true {
+		t.Fatalf("system.log_level upsert result = %v", result)
+	}
+	if got := appLog.CurrentLevel(); got != "debug" {
+		t.Fatalf("runtime log level = %q, want debug", got)
+	}
+	if got := data.GetSettingString(mdb.SettingKeySystemLogLevel, ""); got != "debug" {
+		t.Fatalf("stored system.log_level = %q, want debug", got)
+	}
+
+	rec = doPutAdmin(e, "/admin/api/v1/settings", map[string]interface{}{
+		"items": []map[string]interface{}{
+			{"group": "system", "key": mdb.SettingKeySystemLogLevel, "value": "fatal", "type": "string"},
+			{"group": "rate", "key": mdb.SettingKeySystemLogLevel, "value": "info", "type": "string"},
+			{"group": "system", "key": mdb.SettingKeySystemLogLevel, "value": "", "type": "string"},
+		},
+	}, token)
+	resp = assertOK(t, rec)
+	results, ok = resp["data"].([]interface{})
+	if !ok || len(results) != 3 {
+		t.Fatalf("expected three results, got %T %v", resp["data"], resp["data"])
+	}
+	for _, item := range results {
+		result, _ := item.(map[string]interface{})
+		if result["ok"] != false {
+			t.Fatalf("invalid system.log_level result = %v, want ok=false", result)
+		}
+	}
+	if got := appLog.CurrentLevel(); got != "debug" {
+		t.Fatalf("invalid upsert changed runtime log level to %q", got)
+	}
+
+	rec = doDeleteAdmin(e, "/admin/api/v1/settings/"+mdb.SettingKeySystemLogLevel, token)
+	assertOK(t, rec)
+	if got := appLog.CurrentLevel(); got != mdb.SettingDefaultSystemLogLevel {
+		t.Fatalf("runtime log level after delete = %q, want %q", got, mdb.SettingDefaultSystemLogLevel)
+	}
+	if got := data.GetSettingString(mdb.SettingKeySystemLogLevel, mdb.SettingDefaultSystemLogLevel); got != mdb.SettingDefaultSystemLogLevel {
+		t.Fatalf("deleted system.log_level fallback = %q, want %q", got, mdb.SettingDefaultSystemLogLevel)
+	}
+
+	rec = doPutAdmin(e, "/admin/api/v1/settings", map[string]interface{}{
+		"items": []map[string]interface{}{
+			{"group": "system", "key": mdb.SettingKeySystemLogLevel, "value": "warn", "type": "string"},
+		},
+	}, token)
+	assertOK(t, rec)
+	if got := appLog.CurrentLevel(); got != "warn" {
+		t.Fatalf("runtime log level after restore = %q, want warn", got)
+	}
+
+	var restored mdb.Setting
+	if err := dao.Mdb.Unscoped().Where("`key` = ?", mdb.SettingKeySystemLogLevel).Take(&restored).Error; err != nil {
+		t.Fatalf("load restored system.log_level unscoped: %v", err)
+	}
+	if restored.DeletedAt.Valid {
+		t.Fatalf("restored system.log_level still has deleted_at=%v", restored.DeletedAt)
+	}
+	if restored.Value != "warn" {
+		t.Fatalf("restored system.log_level value = %q, want warn", restored.Value)
+	}
+}
+
 // TestAdminSettings_DeleteNonExistent verifies deleting a non-existent setting.
 func TestAdminSettings_DeleteNonExistent(t *testing.T) {
 	e, token := setupAdminTestEnv(t)

src/route/router.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"net/http"
 	"strconv"
+	"strings"
 
 	"github.com/GMWalletApp/epusdt/controller/admin"
 	"github.com/GMWalletApp/epusdt/controller/comm"
@@ -36,6 +37,7 @@ func RegisterRoute(e *echo.Echo) {
 	})
 
 	payRoute.GET("/checkout-counter-resp/:trade_id", comm.Ctrl.CheckoutCounter)
+	payRoute.GET("/return/:trade_id", comm.Ctrl.ReturnToMerchant)
 	payRoute.GET("/check-status/:trade_id", comm.Ctrl.CheckStatus)
 	payRoute.POST("/submit-tx-hash/:trade_id", comm.Ctrl.SubmitTxHash)
 	payRoute.POST("/switch-network", comm.Ctrl.SwitchNetwork)
@@ -43,7 +45,9 @@ func RegisterRoute(e *echo.Echo) {
 	// payment routes
 	paymentRoute := e.Group("/payments")
 
-	// gmpay v1 routes
+	// gmpay v1 routes. CreateTransaction accepts token+network together
+	// for a concrete chain order, or omits both for a status=4 placeholder
+	// that is completed later by /pay/switch-network or routed to OkPay.
 	gmpayV1 := paymentRoute.Group("/gmpay/v1")
 	gmpayV1.POST("/order/create-transaction", comm.Ctrl.CreateTransaction, middleware.CheckApiSign())
 	gmpayV1.GET("/config", comm.Ctrl.GetPublicConfig)
@@ -129,6 +133,21 @@ func RegisterRoute(e *echo.Echo) {
 		notifyURL := getString(params, "notify_url")
 		outTradeNo := getString(params, "out_trade_no")
 		returnURL := getString(params, "return_url")
+		token := strings.TrimSpace(getString(params, "token"))
+		if token == "" {
+			token = data.GetSettingString(mdb.SettingKeyEpayDefaultToken, "")
+		}
+		network := strings.TrimSpace(getString(params, "network"))
+		if network == "" {
+			network = data.GetSettingString(mdb.SettingKeyEpayDefaultNetwork, "")
+		}
+		currency := strings.TrimSpace(getString(params, "currency"))
+		if currency == "" {
+			currency = data.GetSettingString(mdb.SettingKeyEpayDefaultCurrency, "")
+		}
+		if currency == "" {
+			currency = "cny"
+		}
 
 		amountFloat, err := strconv.ParseFloat(money, 64)
 		if err != nil {
@@ -136,9 +155,9 @@ func RegisterRoute(e *echo.Echo) {
 		}
 
 		body := map[string]interface{}{
-			"token":        data.GetSettingString(mdb.SettingKeyEpayDefaultToken, "usdt"),
+			"token":        token,
-			"currency":     data.GetSettingString(mdb.SettingKeyEpayDefaultCurrency, "cny"),
+			"currency":     currency,
-			"network":      data.GetSettingString(mdb.SettingKeyEpayDefaultNetwork, "tron"),
+			"network":      network,
 			"amount":       amountFloat,
 			"notify_url":   notifyURL,
 			"order_id":     outTradeNo,

src/task/listen.go

@@ -14,6 +14,8 @@ func Start() {
 	go StartPolygonWebSocketListener()
 	go StartPlasmaWebSocketListener()
 	go StartTronBlockScannerListener()
+	go StartTonBlockScannerListener()
+	go StartAptosLedgerScannerListener()
 
 	c := cron.New()
 

src/task/listen_aptos_scanner.go

@@ -0,0 +1,255 @@
+package task
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	"github.com/GMWalletApp/epusdt/model/service"
+	"github.com/GMWalletApp/epusdt/util/log"
+)
+
+const (
+	aptosLedgerChunkSize   int64 = 100
+	aptosLedgerWorkerCount       = 3
+	aptosLedgerQueueLimit        = 100
+)
+
+type aptosRuntimeCursor struct {
+	initialized     bool
+	lastSeenVersion int64
+}
+
+type aptosLedgerRange struct {
+	start int64
+	limit int64
+	state moveWatchState
+}
+
+type aptosChainProvider interface {
+	LatestLedgerVersion() (int64, error)
+	Transactions(start int64, limit int64) ([]byte, error)
+}
+
+type serviceAptosProvider struct{}
+
+func (serviceAptosProvider) LatestLedgerVersion() (int64, error) {
+	return service.AptosGetLedgerVersion()
+}
+
+func (serviceAptosProvider) Transactions(start int64, limit int64) ([]byte, error) {
+	return service.AptosGetTransactions(start, limit)
+}
+
+var (
+	parseAptosTransfersForWallets    = service.ParseAptosTransfersForWallets
+	processAptosObservedTransferFunc = service.ProcessMoveObservedTransferResult
+)
+
+func StartAptosLedgerScannerListener() {
+	provider := serviceAptosProvider{}
+	cursor := &aptosRuntimeCursor{}
+	log.Sugar.Infof("[APTOS] ledger scanner starting mode=full_ledger chunk_size=%d workers=%d queue_limit=%d",
+		aptosLedgerChunkSize,
+		aptosLedgerWorkerCount,
+		aptosLedgerQueueLimit,
+	)
+	for {
+		if err := runAptosLedgerScanner(context.Background(), provider, cursor); err != nil {
+			log.Sugar.Warnf("[APTOS] scanner stopped: %v", err)
+			sleepOrDone(context.Background(), moveScannerRetryDelay)
+			continue
+		}
+	}
+}
+
+func runAptosLedgerScanner(ctx context.Context, provider aptosChainProvider, cursor *aptosRuntimeCursor) error {
+	if cursor == nil {
+		cursor = &aptosRuntimeCursor{}
+	}
+	watchSignature := ""
+	for {
+		chain, interval := moveChainConfig(mdb.NetworkAptos)
+		if chain == nil || !chain.Enabled {
+			log.Sugar.Debug("[APTOS] chain disabled or not configured, idling")
+			if !sleepOrDone(ctx, interval) {
+				return nil
+			}
+			continue
+		}
+		state, err := loadMoveWatchState(mdb.NetworkAptos)
+		if err != nil {
+			return err
+		}
+		if len(state.wallets) == 0 || len(state.tokens) == 0 {
+			log.Sugar.Debug("[APTOS] no enabled wallets or tokens, idling")
+			if !sleepOrDone(ctx, interval) {
+				return nil
+			}
+			continue
+		}
+		if sig := moveWatchStateSignature(state); sig != watchSignature {
+			watchSignature = sig
+			log.Sugar.Infof("[APTOS] ledger scanner watching wallets=%d tokens=%d", len(state.wallets), len(state.tokens))
+		}
+
+		latest, err := provider.LatestLedgerVersion()
+		if err != nil {
+			return fmt.Errorf("get latest ledger version: %w", err)
+		}
+		data.RecordRpcBlockHeight(mdb.NetworkAptos, latest)
+		confirmed := moveConfirmedCursor(latest, chain.MinConfirmations)
+		if !cursor.initialized {
+			cursor.initialized = true
+			cursor.lastSeenVersion = confirmed - aptosLedgerChunkSize
+			if cursor.lastSeenVersion < -1 {
+				cursor.lastSeenVersion = -1
+			}
+			log.Sugar.Infof(
+				"[APTOS] initialized ledger cursor at version=%d confirmed_head=%d chunk_size=%d mode=full_ledger_watch",
+				cursor.lastSeenVersion,
+				confirmed,
+				aptosLedgerChunkSize,
+			)
+		}
+
+		catchup, err := processAptosLedgerRound(ctx, provider, state, cursor, confirmed)
+		if err != nil {
+			return err
+		}
+		if !sleepOrDone(ctx, chooseAptosIdleDelay(catchup, interval)) {
+			return nil
+		}
+	}
+}
+
+func processAptosLedgerRound(ctx context.Context, provider aptosChainProvider, state moveWatchState, cursor *aptosRuntimeCursor, confirmedVersion int64) (bool, error) {
+	ranges := buildAptosLedgerRanges(cursor.lastSeenVersion, confirmedVersion, state)
+	if len(ranges) == 0 {
+		return false, nil
+	}
+	lastRange := ranges[len(ranges)-1]
+	log.Sugar.Infof(
+		"[APTOS] queued ledger ranges count=%d from=%d to=%d cursor=%d confirmed_head=%d workers=%d",
+		len(ranges),
+		ranges[0].start,
+		lastRange.start+lastRange.limit-1,
+		cursor.lastSeenVersion,
+		confirmedVersion,
+		aptosLedgerWorkerCount,
+	)
+
+	type rangeResult struct {
+		item aptosLedgerRange
+		err  error
+	}
+	jobs := make(chan aptosLedgerRange, len(ranges))
+	results := make(chan rangeResult, len(ranges))
+	workers := aptosLedgerWorkerCount
+	if len(ranges) < workers {
+		workers = len(ranges)
+	}
+
+	var wg sync.WaitGroup
+	for i := 0; i < workers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for item := range jobs {
+				results <- rangeResult{item: item, err: processAptosLedgerRange(ctx, provider, item, confirmedVersion)}
+			}
+		}()
+	}
+	for _, item := range ranges {
+		jobs <- item
+	}
+	close(jobs)
+	wg.Wait()
+	close(results)
+
+	errByStart := make(map[int64]error, len(ranges))
+	for result := range results {
+		if result.err != nil {
+			errByStart[result.item.start] = result.err
+		}
+	}
+
+	for _, item := range ranges {
+		if err := errByStart[item.start]; err != nil {
+			return cursor.lastSeenVersion < confirmedVersion, err
+		}
+		cursor.lastSeenVersion = item.start + item.limit - 1
+	}
+	return cursor.lastSeenVersion < confirmedVersion, nil
+}
+
+func buildAptosLedgerRanges(lastSeenVersion int64, confirmedVersion int64, state moveWatchState) []aptosLedgerRange {
+	if confirmedVersion <= lastSeenVersion {
+		return nil
+	}
+	ranges := make([]aptosLedgerRange, 0, aptosLedgerQueueLimit)
+	next := lastSeenVersion + 1
+	if next < 0 {
+		next = 0
+	}
+	for next <= confirmedVersion && len(ranges) < aptosLedgerQueueLimit {
+		limit := confirmedVersion - next + 1
+		if limit > aptosLedgerChunkSize {
+			limit = aptosLedgerChunkSize
+		}
+		ranges = append(ranges, aptosLedgerRange{start: next, limit: limit, state: state})
+		next += limit
+	}
+	return ranges
+}
+
+func processAptosLedgerRange(ctx context.Context, provider aptosChainProvider, item aptosLedgerRange, confirmedVersion int64) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	body, err := provider.Transactions(item.start, item.limit)
+	if err != nil {
+		return fmt.Errorf("get transactions start=%d limit=%d: %w", item.start, item.limit, err)
+	}
+	transfers, err := parseAptosTransfersForWallets(body, item.state.wallets, item.state.tokens)
+	if err != nil {
+		return fmt.Errorf("parse transactions start=%d limit=%d: %w", item.start, item.limit, err)
+	}
+	for _, transfer := range transfers {
+		log.Sugar.Infof(
+			"[APTOS] observed transfer version=%d tx=%s token=%s amount=%.8f raw=%s decimals=%d receive=%s key=%s",
+			transfer.Version,
+			transfer.TxID,
+			transfer.Token,
+			transfer.Amount,
+			transfer.RawAmount.String(),
+			transfer.Decimals,
+			transfer.ReceiveAddress,
+			transfer.TransferKey,
+		)
+		if err = processAptosObservedTransferFunc(transfer); err != nil {
+			return err
+		}
+	}
+	if len(transfers) > 0 {
+		log.Sugar.Infof(
+			"[APTOS] ledger range processed start=%d limit=%d to=%d transfers=%d confirmed_head=%d",
+			item.start,
+			item.limit,
+			item.start+item.limit-1,
+			len(transfers),
+			confirmedVersion,
+		)
+	}
+	return nil
+}
+
+func chooseAptosIdleDelay(catchup bool, interval time.Duration) time.Duration {
+	if catchup {
+		return moveCatchupYield
+	}
+	return interval
+}

src/task/listen_aptos_scanner_test.go

@@ -0,0 +1,440 @@
+package task
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sort"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/GMWalletApp/epusdt/internal/testutil"
+	"github.com/GMWalletApp/epusdt/model/dao"
+	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	"github.com/GMWalletApp/epusdt/model/service"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
+)
+
+type fakeAptosProvider struct {
+	mu sync.Mutex
+
+	latest int64
+
+	bodiesByStart map[int64][]byte
+	errByStart    map[int64]error
+
+	calls []aptosRangeCall
+}
+
+type aptosRangeCall struct {
+	start int64
+	limit int64
+}
+
+func (f *fakeAptosProvider) LatestLedgerVersion() (int64, error) {
+	return f.latest, nil
+}
+
+func (f *fakeAptosProvider) Transactions(start int64, limit int64) ([]byte, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.calls = append(f.calls, aptosRangeCall{start: start, limit: limit})
+	if err := f.errByStart[start]; err != nil {
+		return nil, err
+	}
+	if body := f.bodiesByStart[start]; len(body) > 0 {
+		return append([]byte(nil), body...), nil
+	}
+	return []byte("[]"), nil
+}
+
+func (f *fakeAptosProvider) rangeCalls() []aptosRangeCall {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	calls := append([]aptosRangeCall(nil), f.calls...)
+	sort.Slice(calls, func(i, j int) bool {
+		if calls[i].start == calls[j].start {
+			return calls[i].limit < calls[j].limit
+		}
+		return calls[i].start < calls[j].start
+	})
+	return calls
+}
+
+func resetAptosScannerHooks(t *testing.T) {
+	t.Helper()
+	oldParse := parseAptosTransfersForWallets
+	oldProcess := processAptosObservedTransferFunc
+	t.Cleanup(func() {
+		parseAptosTransfersForWallets = oldParse
+		processAptosObservedTransferFunc = oldProcess
+	})
+}
+
+func seedAptosScannerChain(t *testing.T, wallets ...string) []string {
+	t.Helper()
+	if err := dao.Mdb.Create(&mdb.Chain{Network: mdb.NetworkAptos, Enabled: true, MinConfirmations: 1, ScanIntervalSec: 1}).Error; err != nil {
+		t.Fatalf("seed Aptos chain: %v", err)
+	}
+	if err := dao.Mdb.Create(&[]mdb.ChainToken{
+		{Network: mdb.NetworkAptos, Symbol: "USDC", ContractAddress: "0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b", Decimals: 6, Enabled: true},
+		{Network: mdb.NetworkAptos, Symbol: "USDT", ContractAddress: "0x357b0b74bc833e95a115ad22604854d6b0fca151cecd94111770e5d6ffc9dc2b", Decimals: 6, Enabled: true},
+		{Network: mdb.NetworkAptos, Symbol: "MOVEUSD", ContractAddress: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Decimals: 6, Enabled: true},
+	}).Error; err != nil {
+		t.Fatalf("seed Aptos tokens: %v", err)
+	}
+	if len(wallets) == 0 {
+		wallets = []string{"0xa"}
+	}
+	out := make([]string, 0, len(wallets))
+	for _, wallet := range wallets {
+		receive, err := addressutil.NormalizeMoveAddress(wallet)
+		if err != nil {
+			t.Fatalf("normalize Aptos address %q: %v", wallet, err)
+		}
+		if _, err = data.AddWalletAddressWithNetwork(mdb.NetworkAptos, receive); err != nil {
+			t.Fatalf("seed Aptos wallet %s: %v", receive, err)
+		}
+		out = append(out, receive)
+	}
+	return out
+}
+
+func TestProcessAptosLedgerRangePassesConfiguredTokens(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	resetAptosScannerHooks(t)
+	seedAptosScannerChain(t, "0xa")
+
+	state, err := loadMoveWatchState(mdb.NetworkAptos)
+	if err != nil {
+		t.Fatalf("load state: %v", err)
+	}
+	var gotSymbols []string
+	parseAptosTransfersForWallets = func(_ []byte, _ map[string]struct{}, tokens []mdb.ChainToken) ([]service.MoveObservedTransfer, error) {
+		for _, token := range tokens {
+			gotSymbols = append(gotSymbols, token.Symbol)
+		}
+		sort.Strings(gotSymbols)
+		return nil, nil
+	}
+	provider := &fakeAptosProvider{bodiesByStart: map[int64][]byte{100: []byte("[]")}}
+
+	err = processAptosLedgerRange(context.Background(), provider, aptosLedgerRange{start: 100, limit: 1, state: state}, 100)
+	if err != nil {
+		t.Fatalf("processAptosLedgerRange(): %v", err)
+	}
+	want := []string{"MOVEUSD", "USDC", "USDT"}
+	if len(gotSymbols) != len(want) {
+		t.Fatalf("tokens = %#v, want %#v", gotSymbols, want)
+	}
+	for i := range want {
+		if gotSymbols[i] != want[i] {
+			t.Fatalf("tokens = %#v, want %#v", gotSymbols, want)
+		}
+	}
+}
+
+func TestRunAptosLedgerScannerIdlesWhenChainDisabled(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	resetAptosScannerHooks(t)
+	if err := dao.Mdb.Create(&mdb.Chain{Network: mdb.NetworkAptos, Enabled: false, MinConfirmations: 1, ScanIntervalSec: 1}).Error; err != nil {
+		t.Fatalf("seed disabled Aptos chain: %v", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
+	defer cancel()
+
+	provider := &fakeAptosProvider{latest: 999}
+	cursor := &aptosRuntimeCursor{}
+	if err := runAptosLedgerScanner(ctx, provider, cursor); err != nil {
+		t.Fatalf("runAptosLedgerScanner(): %v", err)
+	}
+	if cursor.initialized {
+		t.Fatalf("cursor initialized while chain disabled: %#v", cursor)
+	}
+	if calls := provider.rangeCalls(); len(calls) != 0 {
+		t.Fatalf("range calls = %#v, want none", calls)
+	}
+}
+
+func TestRunAptosLedgerScannerInitializesAtTrailingConfirmedChunk(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	resetAptosScannerHooks(t)
+	seedAptosScannerChain(t, "0xa")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+	defer cancel()
+
+	provider := &fakeAptosProvider{latest: 999}
+	cursor := &aptosRuntimeCursor{}
+	if err := runAptosLedgerScanner(ctx, provider, cursor); err != nil {
+		t.Fatalf("runAptosLedgerScanner(): %v", err)
+	}
+
+	if !cursor.initialized || cursor.lastSeenVersion != 999 {
+		t.Fatalf("cursor = %#v, want initialized and advanced to confirmed head 999", cursor)
+	}
+	calls := provider.rangeCalls()
+	if len(calls) != 1 || calls[0].start != 900 || calls[0].limit != 100 {
+		t.Fatalf("range calls = %#v, want start=900 limit=100", calls)
+	}
+}
+
+func TestProcessAptosLedgerRoundDoesNotAdvanceUnconfirmedVersion(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	resetAptosScannerHooks(t)
+	seedAptosScannerChain(t, "0xa")
+
+	provider := &fakeAptosProvider{latest: 100}
+	cursor := &aptosRuntimeCursor{initialized: true, lastSeenVersion: 99}
+	state, err := loadMoveWatchState(mdb.NetworkAptos)
+	if err != nil {
+		t.Fatalf("load state: %v", err)
+	}
+
+	catchup, err := processAptosLedgerRound(context.Background(), provider, state, cursor, 99)
+	if err != nil {
+		t.Fatalf("processAptosLedgerRound(): %v", err)
+	}
+	if catchup {
+		t.Fatal("catchup = true, want false")
+	}
+	if cursor.lastSeenVersion != 99 {
+		t.Fatalf("lastSeenVersion = %d, want 99", cursor.lastSeenVersion)
+	}
+	if calls := provider.rangeCalls(); len(calls) != 0 {
+		t.Fatalf("range calls = %#v, want none", calls)
+	}
+}
+
+func TestProcessAptosLedgerRoundAdvancesAfterSuccessfulRange(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	resetAptosScannerHooks(t)
+	seedAptosScannerChain(t, "0xa")
+
+	state, err := loadMoveWatchState(mdb.NetworkAptos)
+	if err != nil {
+		t.Fatalf("load state: %v", err)
+	}
+	provider := &fakeAptosProvider{bodiesByStart: map[int64][]byte{100: []byte("[]")}}
+	cursor := &aptosRuntimeCursor{initialized: true, lastSeenVersion: 99}
+
+	catchup, err := processAptosLedgerRound(context.Background(), provider, state, cursor, 250)
+	if err != nil {
+		t.Fatalf("processAptosLedgerRound(): %v", err)
+	}
+	if catchup {
+		t.Fatal("catchup = true, want false")
+	}
+	if cursor.lastSeenVersion != 250 {
+		t.Fatalf("lastSeenVersion = %d, want 250", cursor.lastSeenVersion)
+	}
+	calls := provider.rangeCalls()
+	if len(calls) != 2 || calls[0].start != 100 || calls[0].limit != 100 || calls[1].start != 200 || calls[1].limit != 51 {
+		t.Fatalf("range calls = %#v, want [100/100 200/51]", calls)
+	}
+}
+
+func TestProcessAptosLedgerRoundDoesNotAdvanceOnRangeFailure(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	resetAptosScannerHooks(t)
+	seedAptosScannerChain(t, "0xa")
+
+	state, err := loadMoveWatchState(mdb.NetworkAptos)
+	if err != nil {
+		t.Fatalf("load state: %v", err)
+	}
+	provider := &fakeAptosProvider{errByStart: map[int64]error{100: errors.New("temporary rpc failure")}}
+	cursor := &aptosRuntimeCursor{initialized: true, lastSeenVersion: 99}
+
+	if _, err = processAptosLedgerRound(context.Background(), provider, state, cursor, 150); err == nil {
+		t.Fatal("processAptosLedgerRound() error = nil, want error")
+	}
+	if cursor.lastSeenVersion != 99 {
+		t.Fatalf("lastSeenVersion = %d, want 99", cursor.lastSeenVersion)
+	}
+}
+
+func TestProcessAptosLedgerRoundProcessesMultipleChunks(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	resetAptosScannerHooks(t)
+	seedAptosScannerChain(t, "0xa")
+
+	state, err := loadMoveWatchState(mdb.NetworkAptos)
+	if err != nil {
+		t.Fatalf("load state: %v", err)
+	}
+	provider := &fakeAptosProvider{
+		bodiesByStart: map[int64][]byte{
+			100: []byte("[]"),
+			200: []byte("[]"),
+		},
+	}
+	cursor := &aptosRuntimeCursor{initialized: true, lastSeenVersion: 99}
+
+	catchup, err := processAptosLedgerRound(context.Background(), provider, state, cursor, 250)
+	if err != nil {
+		t.Fatalf("processAptosLedgerRound(): %v", err)
+	}
+	if catchup {
+		t.Fatal("catchup = true, want false")
+	}
+	if cursor.lastSeenVersion != 250 {
+		t.Fatalf("lastSeenVersion = %d, want 250", cursor.lastSeenVersion)
+	}
+	calls := provider.rangeCalls()
+	if len(calls) != 2 || calls[0].start != 100 || calls[0].limit != 100 || calls[1].start != 200 || calls[1].limit != 51 {
+		t.Fatalf("range calls = %#v, want [100/100 200/51]", calls)
+	}
+}
+
+func TestBuildAptosLedgerRangesStopsAtQueueLimit(t *testing.T) {
+	state := moveWatchState{}
+	ranges := buildAptosLedgerRanges(0, aptosLedgerChunkSize*aptosLedgerQueueLimit+500, state)
+	if len(ranges) != aptosLedgerQueueLimit {
+		t.Fatalf("ranges len = %d, want %d", len(ranges), aptosLedgerQueueLimit)
+	}
+	first := ranges[0]
+	last := ranges[len(ranges)-1]
+	if first.start != 1 || first.limit != aptosLedgerChunkSize {
+		t.Fatalf("first range = %#v, want start=1 limit=%d", first, aptosLedgerChunkSize)
+	}
+	if last.start != 1+aptosLedgerChunkSize*int64(aptosLedgerQueueLimit-1) || last.limit != aptosLedgerChunkSize {
+		t.Fatalf("last range = %#v", last)
+	}
+}
+
+func TestProcessAptosLedgerRoundMarksMatchingUSDTOrderPaid(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	resetAptosScannerHooks(t)
+	wallets := seedAptosScannerChain(t, "0xa")
+	receive := wallets[0]
+	amount := 3.1
+	tradeID := "aptos_trade_1"
+	usdt := "0x357b0b74bc833e95a115ad22604854d6b0fca151cecd94111770e5d6ffc9dc2b"
+	body := aptosFungibleTransferBody(t, "0xabc", 101, receive, usdt, "3100000")
+
+	order := &mdb.Orders{
+		TradeId:         tradeID,
+		OrderId:         "aptos_order_1",
+		Amount:          amount,
+		ActualAmount:    amount,
+		ReceiveAddress:  receive,
+		Token:           "USDT",
+		Network:         mdb.NetworkAptos,
+		Status:          mdb.StatusWaitPay,
+		CallBackConfirm: mdb.CallBackConfirmOk,
+		PaymentType:     mdb.PaymentTypeGmpay,
+		PayProvider:     mdb.PaymentProviderOnChain,
+	}
+	if err := dao.Mdb.Create(order).Error; err != nil {
+		t.Fatalf("create order: %v", err)
+	}
+	if err := data.LockTransaction(mdb.NetworkAptos, receive, "USDT", tradeID, amount, time.Hour); err != nil {
+		t.Fatalf("lock transaction: %v", err)
+	}
+
+	state, err := loadMoveWatchState(mdb.NetworkAptos)
+	if err != nil {
+		t.Fatalf("load state: %v", err)
+	}
+	provider := &fakeAptosProvider{bodiesByStart: map[int64][]byte{101: body}}
+	cursor := &aptosRuntimeCursor{initialized: true, lastSeenVersion: 100}
+
+	if _, err = processAptosLedgerRound(context.Background(), provider, state, cursor, 101); err != nil {
+		t.Fatalf("processAptosLedgerRound(): %v", err)
+	}
+	paid, err := data.GetOrderInfoByTradeId(tradeID)
+	if err != nil {
+		t.Fatalf("reload order: %v", err)
+	}
+	if paid.Status != mdb.StatusPaySuccess || paid.CallBackConfirm != mdb.CallBackConfirmNo || paid.BlockTransactionId != "0xabc" {
+		t.Fatalf("paid order = %#v", paid)
+	}
+	lockTradeID, err := data.GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkAptos, receive, "USDT", amount)
+	if err != nil {
+		t.Fatalf("lookup lock: %v", err)
+	}
+	if lockTradeID != "" {
+		t.Fatalf("transaction lock still exists: %s", lockTradeID)
+	}
+}
+
+func TestProcessAptosLedgerRoundDoesNotReprocessDuplicateTransferKey(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	resetAptosScannerHooks(t)
+	wallets := seedAptosScannerChain(t, "0xa")
+	receive := wallets[0]
+	usdc := "0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b"
+
+	state, err := loadMoveWatchState(mdb.NetworkAptos)
+	if err != nil {
+		t.Fatalf("load state: %v", err)
+	}
+	provider := &fakeAptosProvider{
+		bodiesByStart: map[int64][]byte{
+			101: aptosFungibleTransferBody(t, "0xabc", 101, receive, usdc, "1200000"),
+			102: aptosFungibleTransferBody(t, "0xabc", 101, receive, usdc, "1200000"),
+		},
+	}
+	var processed int
+	processAptosObservedTransferFunc = func(transfer service.MoveObservedTransfer) error {
+		processed++
+		return service.ProcessMoveObservedTransferResult(transfer)
+	}
+	cursor := &aptosRuntimeCursor{initialized: true, lastSeenVersion: 100}
+
+	if _, err = processAptosLedgerRound(context.Background(), provider, state, cursor, 101); err != nil {
+		t.Fatalf("first processAptosLedgerRound(): %v", err)
+	}
+	if _, err = processAptosLedgerRound(context.Background(), provider, state, cursor, 102); err != nil {
+		t.Fatalf("second processAptosLedgerRound(): %v", err)
+	}
+	if processed != 2 {
+		t.Fatalf("scanner processed callback count = %d, want 2", processed)
+	}
+	if cursor.lastSeenVersion != 102 {
+		t.Fatalf("lastSeenVersion = %d, want 102", cursor.lastSeenVersion)
+	}
+}
+
+func aptosFungibleTransferBody(t *testing.T, hash string, version int64, receive string, metadata string, rawAmount string) []byte {
+	t.Helper()
+	store, err := addressutil.NormalizeMoveAddress(fmt.Sprintf("0x%x", version+1000))
+	if err != nil {
+		t.Fatalf("normalize store: %v", err)
+	}
+	senderStore, err := addressutil.NormalizeMoveAddress(fmt.Sprintf("0x%x", version+2000))
+	if err != nil {
+		t.Fatalf("normalize sender store: %v", err)
+	}
+	return []byte(`[
+		{
+			"type":"user_transaction",
+			"success":true,
+			"hash":"` + hash + `",
+			"version":"` + fmt.Sprintf("%d", version) + `",
+			"timestamp":"` + fmt.Sprintf("%d", time.Now().UnixMicro()) + `",
+			"events":[
+				{"type":"0x1::fungible_asset::Withdraw","data":{"amount":"` + rawAmount + `","store":"` + senderStore + `"}},
+				{"type":"0x1::fungible_asset::Deposit","data":{"amount":"` + rawAmount + `","store":"` + store + `"}}
+			],
+			"changes":[
+				{"address":"` + senderStore + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + metadata + `"}}},"type":"write_resource"},
+				{"address":"` + store + `","data":{"type":"0x1::fungible_asset::FungibleStore","data":{"metadata":{"inner":"` + metadata + `"}}},"type":"write_resource"},
+				{"address":"` + store + `","data":{"type":"0x1::object::ObjectCore","data":{"owner":"` + receive + `"}},"type":"write_resource"}
+			]
+		}
+	]`)
+}

src/task/listen_move_common.go

@@ -0,0 +1,77 @@
+package task
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
+	"github.com/GMWalletApp/epusdt/util/log"
+)
+
+const (
+	moveScannerRetryDelay = 3 * time.Second
+	moveCatchupYield      = 250 * time.Millisecond
+)
+
+type moveWatchState struct {
+	wallets map[string]struct{}
+	tokens  []mdb.ChainToken
+}
+
+func moveChainConfig(network string) (*mdb.Chain, time.Duration) {
+	row, err := data.GetChainByNetwork(network)
+	if err != nil || row == nil || row.ID == 0 {
+		if err != nil {
+			log.Sugar.Warnf("[%s] load chain config failed: %v", strings.ToUpper(network), err)
+		}
+		return nil, 5 * time.Second
+	}
+	interval := time.Duration(row.ScanIntervalSec) * time.Second
+	if interval <= 0 {
+		interval = 5 * time.Second
+	}
+	return row, interval
+}
+
+func loadMoveWatchState(network string) (moveWatchState, error) {
+	rows, err := data.GetAvailableWalletAddressByNetwork(network)
+	if err != nil {
+		return moveWatchState{}, err
+	}
+	state := moveWatchState{wallets: make(map[string]struct{})}
+	for _, row := range rows {
+		address, err := addressutil.NormalizeMoveAddress(row.Address)
+		if err != nil {
+			log.Sugar.Warnf("[%s] skip invalid wallet address=%s err=%v", strings.ToUpper(network), row.Address, err)
+			continue
+		}
+		state.wallets[address] = struct{}{}
+	}
+	tokens, err := data.ListEnabledChainTokensByNetwork(network)
+	if err != nil {
+		return moveWatchState{}, err
+	}
+	state.tokens = tokens
+	return state, nil
+}
+
+func moveWatchStateSignature(state moveWatchState) string {
+	return fmt.Sprintf("wallets=%d/tokens=%d", len(state.wallets), len(state.tokens))
+}
+
+func moveConfirmedCursor(latest int64, minConfirmations int) int64 {
+	if latest <= 0 {
+		return 0
+	}
+	if minConfirmations <= 1 {
+		return latest
+	}
+	confirmed := latest - int64(minConfirmations) + 1
+	if confirmed < 0 {
+		return 0
+	}
+	return confirmed
+}

src/task/listen_ton.go

@@ -0,0 +1,574 @@
+package task
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	"github.com/GMWalletApp/epusdt/model/service"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
+	"github.com/GMWalletApp/epusdt/util/log"
+	"github.com/xssnick/tonutils-go/address"
+	"github.com/xssnick/tonutils-go/ton"
+	"github.com/xssnick/tonutils-go/ton/jetton"
+)
+
+const (
+	tonMasterShard           = int64(-0x8000000000000000)
+	tonScannerConnectTimeout = 20 * time.Second
+	tonScannerRequestTimeout = 15 * time.Second
+	tonScannerRetryDelay     = 3 * time.Second
+	tonCatchupYield          = 250 * time.Millisecond
+	tonMaxMasterBlocksTick   = uint32(50)
+	tonBlockTxPageSize       = uint32(256)
+)
+
+type tonWatchState struct {
+	wallets      map[string]*address.Address
+	nativeToken  *mdb.ChainToken
+	jettonTokens []mdb.ChainToken
+}
+
+func (s *tonWatchState) hasWalletInWorkchain(workchain int32) bool {
+	if s == nil {
+		return false
+	}
+	for _, wallet := range s.wallets {
+		if wallet != nil && wallet.Workchain() == workchain {
+			return true
+		}
+	}
+	return false
+}
+
+type tonRuntimeCursor struct {
+	initialized     bool
+	lastMasterSeqNo uint32
+	shardSeqNo      map[string]uint32
+}
+
+func (c *tonRuntimeCursor) ensureShardSeqNo() {
+	if c.shardSeqNo == nil {
+		c.shardSeqNo = make(map[string]uint32)
+	}
+}
+
+type tonJettonWalletCache struct {
+	sync.Mutex
+	walletByOwnerToken map[string]string
+}
+
+func newTonJettonWalletCache() *tonJettonWalletCache {
+	return &tonJettonWalletCache{walletByOwnerToken: make(map[string]string)}
+}
+
+// StartTonBlockScannerListener runs a forward-only TON masterchain scanner.
+func StartTonBlockScannerListener() {
+	cache := newTonJettonWalletCache()
+	cursor := &tonRuntimeCursor{}
+	for {
+		chain, interval := tonChainConfig()
+		if chain == nil || !chain.Enabled {
+			sleepOrDone(context.Background(), interval)
+			continue
+		}
+		node, ok := resolveTonLiteNode()
+		if !ok {
+			sleepOrDone(context.Background(), interval)
+			continue
+		}
+		log.Sugar.Infof("[TON] connecting using lite node %s", data.RpcNodeLogLabel(node))
+		api, closeFn, err := connectTonLiteAPI(node)
+		if err != nil {
+			log.Sugar.Warnf("[TON] connect lite node %s failed: %v", data.RpcNodeLogLabel(node), err)
+			recordTonLiteNodeFailure(node, "connect")
+			sleepOrDone(context.Background(), tonScannerRetryDelay)
+			continue
+		}
+		log.Sugar.Infof("[TON] connected using lite node %s", data.RpcNodeLogLabel(node))
+		err = runTonScanner(context.Background(), api, cache, cursor)
+		closeFn()
+		if err != nil {
+			log.Sugar.Warnf("[TON] scanner stopped: %v", err)
+			recordTonLiteNodeFailure(node, err.Error())
+			sleepOrDone(context.Background(), tonScannerRetryDelay)
+			continue
+		}
+	}
+}
+
+func runTonScanner(ctx context.Context, api ton.APIClientWrapped, cache *tonJettonWalletCache, cursor *tonRuntimeCursor) error {
+	if cursor == nil {
+		cursor = &tonRuntimeCursor{}
+	}
+	watchSignature := ""
+	for {
+		chain, interval := tonChainConfig()
+		if chain == nil || !chain.Enabled {
+			return nil
+		}
+		state, err := loadTonWatchState()
+		if err != nil {
+			return err
+		}
+		if len(state.wallets) == 0 || (state.nativeToken == nil && len(state.jettonTokens) == 0) {
+			log.Sugar.Debug("[TON] no enabled wallets or tokens, idling")
+			if !sleepOrDone(ctx, interval) {
+				return nil
+			}
+			continue
+		}
+		if sig := tonWatchStateSignature(state); sig != watchSignature {
+			watchSignature = sig
+			log.Sugar.Infof(
+				"[TON] watching wallets=%d native_ton=%t jetton_tokens=%d wallet_workchains=%s",
+				len(state.wallets),
+				state.nativeToken != nil,
+				len(state.jettonTokens),
+				tonWalletWorkchainSummary(state),
+			)
+		}
+
+		head, err := api.CurrentMasterchainInfo(ctx)
+		if err != nil {
+			data.RecordRpcFailure(mdb.NetworkTon)
+			return fmt.Errorf("current masterchain info: %w", err)
+		}
+		confirmedHeadSeqNo := tonConfirmedMasterSeqNo(head.SeqNo, chain.MinConfirmations)
+		data.RecordRpcSuccess(mdb.NetworkTon)
+		data.RecordRpcBlockHeight(mdb.NetworkTon, int64(head.SeqNo))
+
+		if !cursor.initialized {
+			if err = initializeTonRuntimeCursor(ctx, api, head, confirmedHeadSeqNo, cursor); err != nil {
+				data.RecordRpcFailure(mdb.NetworkTon)
+				return err
+			}
+			log.Sugar.Infof(
+				"[TON] current masterchain head=%d confirmed=%d root=%s file=%s",
+				head.SeqNo,
+				confirmedHeadSeqNo,
+				shortTonHash(head.RootHash),
+				shortTonHash(head.FileHash),
+			)
+			log.Sugar.Infof("[TON] initialized runtime cursor at masterchain seqno=%d head=%d", cursor.lastMasterSeqNo, head.SeqNo)
+			if !sleepOrDone(ctx, interval) {
+				return nil
+			}
+			continue
+		}
+		if cursor.lastMasterSeqNo >= confirmedHeadSeqNo {
+			if !sleepOrDone(ctx, interval) {
+				return nil
+			}
+			continue
+		}
+
+		target := cursor.lastMasterSeqNo + tonMaxMasterBlocksTick
+		if target > confirmedHeadSeqNo {
+			target = confirmedHeadSeqNo
+		}
+		log.Sugar.Infof("[TON] processing masterchain blocks from=%d to=%d head=%d confirmed=%d", cursor.lastMasterSeqNo+1, target, head.SeqNo, confirmedHeadSeqNo)
+		for seq := cursor.lastMasterSeqNo + 1; seq <= target; seq++ {
+			master, err := api.WaitForBlock(seq).LookupBlock(ctx, address.MasterchainID, tonMasterShard, seq)
+			if err != nil {
+				data.RecordRpcFailure(mdb.NetworkTon)
+				return fmt.Errorf("lookup masterchain seqno=%d: %w", seq, err)
+			}
+			if err = processTonMasterBlockWithCursor(ctx, api, master, state, cache, cursor); err != nil {
+				data.RecordRpcFailure(mdb.NetworkTon)
+				return fmt.Errorf("process masterchain seqno=%d: %w", seq, err)
+			}
+			cursor.lastMasterSeqNo = master.SeqNo
+			data.RecordRpcSuccess(mdb.NetworkTon)
+			data.RecordRpcBlockHeight(mdb.NetworkTon, int64(seq))
+		}
+		if target < confirmedHeadSeqNo {
+			if !sleepOrDone(ctx, tonCatchupYield) {
+				return nil
+			}
+		}
+	}
+}
+
+func tonConfirmedMasterSeqNo(headSeqNo uint32, minConfirmations int) uint32 {
+	if minConfirmations <= 1 {
+		return headSeqNo
+	}
+	conf := uint32(minConfirmations)
+	if headSeqNo < conf-1 {
+		return 0
+	}
+	return headSeqNo - conf + 1
+}
+
+func initializeTonRuntimeCursor(ctx context.Context, api ton.APIClientWrapped, head *ton.BlockIDExt, confirmedHeadSeqNo uint32, cursor *tonRuntimeCursor) error {
+	if cursor == nil {
+		return nil
+	}
+	if head == nil {
+		return fmt.Errorf("current masterchain head is nil")
+	}
+	initMaster := head
+	if confirmedHeadSeqNo > 0 && confirmedHeadSeqNo != head.SeqNo {
+		var err error
+		initMaster, err = api.WaitForBlock(confirmedHeadSeqNo).LookupBlock(ctx, address.MasterchainID, tonMasterShard, confirmedHeadSeqNo)
+		if err != nil {
+			return fmt.Errorf("lookup initial confirmed masterchain seqno=%d: %w", confirmedHeadSeqNo, err)
+		}
+	}
+	if confirmedHeadSeqNo > 0 {
+		if err := initializeTonShardCursors(ctx, api, initMaster, cursor); err != nil {
+			return fmt.Errorf("initialize shard cursors masterchain seqno=%d: %w", initMaster.SeqNo, err)
+		}
+	}
+	cursor.initialized = true
+	cursor.lastMasterSeqNo = confirmedHeadSeqNo
+	return nil
+}
+
+func processTonMasterBlock(ctx context.Context, api ton.APIClientWrapped, master *ton.BlockIDExt, state *tonWatchState, cache *tonJettonWalletCache) error {
+	return processTonMasterBlockWithCursor(ctx, api, master, state, cache, nil)
+}
+
+func processTonMasterBlockWithCursor(ctx context.Context, api ton.APIClientWrapped, master *ton.BlockIDExt, state *tonWatchState, cache *tonJettonWalletCache, cursor *tonRuntimeCursor) error {
+	if state.hasWalletInWorkchain(address.MasterchainID) {
+		if err := processTonShardBlock(ctx, api, master, master, state, cache); err != nil {
+			return fmt.Errorf("process masterchain transactions: %w", err)
+		}
+	}
+	shards, err := api.WaitForBlock(master.SeqNo).GetBlockShardsInfo(ctx, master)
+	if err != nil {
+		return err
+	}
+	log.Sugar.Debugf(
+		"[TON] masterchain seqno=%d root=%s file=%s shard_blocks=%d workchains=%s",
+		master.SeqNo,
+		shortTonHash(master.RootHash),
+		shortTonHash(master.FileHash),
+		len(shards),
+		tonShardWorkchainSummary(shards),
+	)
+	if cursor != nil {
+		return processTonShardBlocksWithCursor(ctx, api, master, shards, state, cache, cursor)
+	}
+	for _, shard := range shards {
+		if err = processTonShardBlock(ctx, api, master, shard, state, cache); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func initializeTonShardCursors(ctx context.Context, api ton.APIClientWrapped, master *ton.BlockIDExt, cursor *tonRuntimeCursor) error {
+	if cursor == nil || master == nil {
+		return nil
+	}
+	shards, err := api.WaitForBlock(master.SeqNo).GetBlockShardsInfo(ctx, master)
+	if err != nil {
+		return err
+	}
+	cursor.ensureShardSeqNo()
+	for _, shard := range shards {
+		if shard == nil {
+			continue
+		}
+		cursor.shardSeqNo[tonShardCursorKey(shard)] = shard.SeqNo
+	}
+	log.Sugar.Infof(
+		"[TON] initialized shard cursors masterchain seqno=%d shard_blocks=%d workchains=%s",
+		master.SeqNo,
+		len(shards),
+		tonShardWorkchainSummary(shards),
+	)
+	return nil
+}
+
+func processTonShardBlocksWithCursor(ctx context.Context, api ton.APIClientWrapped, master *ton.BlockIDExt, shards []*ton.BlockIDExt, state *tonWatchState, cache *tonJettonWalletCache, cursor *tonRuntimeCursor) error {
+	if cursor == nil {
+		return nil
+	}
+	cursor.ensureShardSeqNo()
+	for _, shard := range shards {
+		if shard == nil {
+			continue
+		}
+		key := tonShardCursorKey(shard)
+		lastSeqNo, ok := cursor.shardSeqNo[key]
+		if !state.hasWalletInWorkchain(shard.Workchain) {
+			cursor.shardSeqNo[key] = shard.SeqNo
+			continue
+		}
+
+		start := shard.SeqNo
+		if ok {
+			if shard.SeqNo <= lastSeqNo {
+				continue
+			}
+			start = lastSeqNo + 1
+		}
+		if shard.SeqNo > start {
+			log.Sugar.Infof(
+				"[TON] processing shard blocks master_seqno=%d workchain=%d shard=%x from=%d to=%d",
+				master.SeqNo,
+				shard.Workchain,
+				uint64(shard.Shard),
+				start,
+				shard.SeqNo,
+			)
+		}
+		for seq := start; seq <= shard.SeqNo; seq++ {
+			shardBlock := shard
+			if seq != shard.SeqNo {
+				var err error
+				shardBlock, err = api.WaitForBlock(master.SeqNo).LookupBlock(ctx, shard.Workchain, shard.Shard, seq)
+				if err != nil {
+					return fmt.Errorf("lookup shard block workchain=%d shard=%x seqno=%d: %w", shard.Workchain, uint64(shard.Shard), seq, err)
+				}
+			}
+			if err := processTonShardBlock(ctx, api, master, shardBlock, state, cache); err != nil {
+				return err
+			}
+			cursor.shardSeqNo[key] = seq
+		}
+	}
+	return nil
+}
+
+func processTonShardBlock(ctx context.Context, api ton.APIClientWrapped, master, shard *ton.BlockIDExt, state *tonWatchState, cache *tonJettonWalletCache) error {
+	log.Sugar.Debugf("[TON] scanning shard master_seqno=%d workchain=%d shard=%d shard_seqno=%d", master.SeqNo, shard.Workchain, shard.Shard, shard.SeqNo)
+	var after *ton.TransactionID3
+	for {
+		shorts, incomplete, err := api.WaitForBlock(master.SeqNo).GetBlockTransactionsV2(ctx, shard, tonBlockTxPageSize, after)
+		if err != nil {
+			return err
+		}
+		for i := range shorts {
+			account := addressutil.TonAddressFromShortAccount(shard.Workchain, shorts[i].Account)
+			if account == nil {
+				continue
+			}
+			receive, ok := state.wallets[addressutil.TonRawAddressObjectKey(account)]
+			if !ok {
+				continue
+			}
+			log.Sugar.Debugf("[TON] watched account tx candidate master_seqno=%d workchain=%d shard=%d lt=%d account=%s", master.SeqNo, shard.Workchain, shard.Shard, shorts[i].LT, addressutil.TonRawAddressObjectKey(account))
+			tx, err := api.WaitForBlock(master.SeqNo).GetTransaction(ctx, shard, account, shorts[i].LT)
+			if err != nil {
+				return err
+			}
+			if tx == nil {
+				return fmt.Errorf("missing full transaction workchain=%d shard=%d seqno=%d lt=%d", shard.Workchain, shard.Shard, shard.SeqNo, shorts[i].LT)
+			}
+			jettonWallets, err := cache.jettonWalletTokens(ctx, api, master, receive, state.jettonTokens)
+			if err != nil {
+				return err
+			}
+			transfer, err := service.ParseTonInboundTransfer(tx, receive, state.nativeToken, jettonWallets)
+			if err != nil {
+				log.Sugar.Warnf("[TON] parse inbound tx lt=%d hash=%s: %v", tx.LT, hex.EncodeToString(tx.Hash), err)
+				continue
+			}
+			if transfer == nil {
+				log.Sugar.Debugf(
+					"[TON] unsupported watched tx master_seqno=%d workchain=%d shard=%d lt=%d hash=%s account=%s",
+					master.SeqNo,
+					shard.Workchain,
+					shard.Shard,
+					tx.LT,
+					hex.EncodeToString(tx.Hash),
+					addressutil.TonRawAddressObjectKey(account),
+				)
+				continue
+			}
+			service.TryProcessTonTransfer(transfer)
+		}
+		if !incomplete {
+			return nil
+		}
+		if len(shorts) == 0 {
+			return fmt.Errorf("incomplete transaction page without cursor progress workchain=%d shard=%d seqno=%d", shard.Workchain, shard.Shard, shard.SeqNo)
+		}
+		after = shorts[len(shorts)-1].ID3()
+	}
+}
+
+func (c *tonJettonWalletCache) jettonWalletTokens(ctx context.Context, api ton.APIClientWrapped, master *ton.BlockIDExt, owner *address.Address, tokens []mdb.ChainToken) (map[string]mdb.ChainToken, error) {
+	out := make(map[string]mdb.ChainToken, len(tokens))
+	ownerRaw := addressutil.TonRawAddressObjectKey(owner)
+	for _, token := range tokens {
+		masterParsed, err := addressutil.ParseTonMainnetAddress(token.ContractAddress)
+		if err != nil {
+			return nil, fmt.Errorf("invalid jetton master symbol=%s address=%s: %w", token.Symbol, token.ContractAddress, err)
+		}
+		cacheKey := masterParsed.Raw + "|" + ownerRaw
+		c.Lock()
+		walletRaw, ok := c.walletByOwnerToken[cacheKey]
+		c.Unlock()
+		if !ok {
+			wallet, err := jetton.NewJettonMasterClient(api, masterParsed.Address).GetJettonWalletAtBlock(ctx, owner, master)
+			if err != nil {
+				return nil, fmt.Errorf("derive jetton wallet symbol=%s owner=%s: %w", token.Symbol, ownerRaw, err)
+			}
+			walletRaw = addressutil.TonRawAddressObjectKey(wallet.Address())
+			c.Lock()
+			c.walletByOwnerToken[cacheKey] = walletRaw
+			c.Unlock()
+		}
+		out[walletRaw] = token
+	}
+	return out, nil
+}
+
+func loadTonWatchState() (*tonWatchState, error) {
+	walletRows, err := data.GetAvailableWalletAddressByNetwork(mdb.NetworkTon)
+	if err != nil {
+		return nil, err
+	}
+	tokens, err := data.ListEnabledChainTokensByNetwork(mdb.NetworkTon)
+	if err != nil {
+		return nil, err
+	}
+	state := &tonWatchState{wallets: make(map[string]*address.Address)}
+	for _, row := range walletRows {
+		parsed, err := addressutil.ParseTonMainnetAddress(row.Address)
+		if err != nil {
+			log.Sugar.Warnf("[TON] skip invalid wallet address=%s err=%v", row.Address, err)
+			continue
+		}
+		state.wallets[parsed.Raw] = parsed.Address
+	}
+	for i := range tokens {
+		sym := strings.ToUpper(strings.TrimSpace(tokens[i].Symbol))
+		contract := strings.TrimSpace(tokens[i].ContractAddress)
+		switch {
+		case sym == service.TonNativeSymbol && contract == "":
+			token := tokens[i]
+			state.nativeToken = &token
+		case contract != "":
+			state.jettonTokens = append(state.jettonTokens, tokens[i])
+		}
+	}
+	return state, nil
+}
+
+func tonChainConfig() (*mdb.Chain, time.Duration) {
+	row, err := data.GetChainByNetwork(mdb.NetworkTon)
+	if err != nil || row.ID == 0 {
+		return nil, 5 * time.Second
+	}
+	interval := time.Duration(row.ScanIntervalSec) * time.Second
+	if interval <= 0 {
+		interval = 5 * time.Second
+	}
+	return row, interval
+}
+
+func tonWatchStateSignature(state *tonWatchState) string {
+	if state == nil {
+		return ""
+	}
+	return fmt.Sprintf("%d|%t|%d|%s", len(state.wallets), state.nativeToken != nil, len(state.jettonTokens), tonWalletWorkchainSummary(state))
+}
+
+func tonWalletWorkchainSummary(state *tonWatchState) string {
+	if state == nil || len(state.wallets) == 0 {
+		return "none"
+	}
+	counts := make(map[int32]int)
+	for _, wallet := range state.wallets {
+		if wallet == nil {
+			continue
+		}
+		counts[wallet.Workchain()]++
+	}
+	return formatTonWorkchainCounts(counts)
+}
+
+func tonShardWorkchainSummary(shards []*ton.BlockIDExt) string {
+	if len(shards) == 0 {
+		return "none"
+	}
+	counts := make(map[int32]int)
+	for _, shard := range shards {
+		if shard == nil {
+			continue
+		}
+		counts[shard.Workchain]++
+	}
+	return formatTonWorkchainCounts(counts)
+}
+
+func tonShardCursorKey(shard *ton.BlockIDExt) string {
+	if shard == nil {
+		return ""
+	}
+	return fmt.Sprintf("%d:%d", shard.Workchain, shard.Shard)
+}
+
+func formatTonWorkchainCounts(counts map[int32]int) string {
+	if len(counts) == 0 {
+		return "none"
+	}
+	workchains := make([]int, 0, len(counts))
+	for workchain := range counts {
+		workchains = append(workchains, int(workchain))
+	}
+	sort.Ints(workchains)
+	parts := make([]string, 0, len(workchains))
+	for _, workchain := range workchains {
+		parts = append(parts, fmt.Sprintf("%d:%d", workchain, counts[int32(workchain)]))
+	}
+	return strings.Join(parts, ",")
+}
+
+func shortTonHash(raw []byte) string {
+	hash := hex.EncodeToString(raw)
+	if len(hash) > 16 {
+		return hash[:16]
+	}
+	if hash == "" {
+		return "-"
+	}
+	return hash
+}
+
+func resolveTonLiteNode(excludeIDs ...uint64) (mdb.RpcNode, bool) {
+	node, err := data.SelectGeneralRpcNode(mdb.NetworkTon, mdb.RpcNodeTypeLite, excludeIDs...)
+	if err == nil && node != nil && node.ID > 0 {
+		node.Url = strings.TrimSpace(node.Url)
+		if node.Url != "" {
+			return *node, true
+		}
+		log.Sugar.Errorf("[TON] rpc_nodes id=%d has empty url", node.ID)
+		return mdb.RpcNode{}, false
+	}
+	if err != nil {
+		log.Sugar.Errorf("[TON] resolve lite rpc_nodes err=%v", err)
+	} else {
+		log.Sugar.Warn("[TON] no enabled lite RPC node configured in rpc_nodes")
+	}
+	return mdb.RpcNode{}, false
+}
+
+func connectTonLiteAPI(node mdb.RpcNode) (ton.APIClientWrapped, func(), error) {
+	ctx, cancel := context.WithTimeout(context.Background(), tonScannerConnectTimeout)
+	defer cancel()
+	return service.ConnectTonLiteAPI(ctx, node.Url, tonScannerRequestTimeout, 5)
+}
+
+func recordTonLiteNodeFailure(node mdb.RpcNode, reason string) {
+	data.RecordRpcFailure(mdb.NetworkTon)
+	failures, cooling := data.RecordRpcNodeFailure(node.ID)
+	nodeLabel := data.RpcNodeLogLabel(node)
+	if cooling {
+		log.Sugar.Warnf("[TON] lite node reached fail threshold (%s), node=%s failures=%d/%d", reason, nodeLabel, failures, data.RpcFailoverThreshold)
+		return
+	}
+	log.Sugar.Warnf("[TON] lite node failed (%s), node=%s failures=%d/%d", reason, nodeLabel, failures, data.RpcFailoverThreshold)
+}

src/task/listen_ton_test.go

@@ -0,0 +1,717 @@
+package task
+
+import (
+	"bytes"
+	"context"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/GMWalletApp/epusdt/internal/testutil"
+	"github.com/GMWalletApp/epusdt/model/dao"
+	"github.com/GMWalletApp/epusdt/model/data"
+	"github.com/GMWalletApp/epusdt/model/mdb"
+	"github.com/GMWalletApp/epusdt/model/request"
+	"github.com/GMWalletApp/epusdt/model/service"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
+	"github.com/xssnick/tonutils-go/address"
+	"github.com/xssnick/tonutils-go/tlb"
+	"github.com/xssnick/tonutils-go/ton"
+	"github.com/xssnick/tonutils-go/ton/jetton"
+	"github.com/xssnick/tonutils-go/tvm/cell"
+)
+
+type fakeTonShardAPI struct {
+	ton.APIClientWrapped
+	shorts             []ton.TransactionShortInfo
+	shortsByShardSeq   map[uint32][]ton.TransactionShortInfo
+	incomplete         bool
+	shards             []*ton.BlockIDExt
+	shardsErr          error
+	lookupBlocks       map[uint32]*ton.BlockIDExt
+	lookupSeqs         []uint32
+	txByLT             map[uint64]*tlb.Transaction
+	fetchedLTs         []uint64
+	fetchedAddrs       []string
+	fetchedShardSeqNos []uint32
+}
+
+type fakeTonScannerAPI struct {
+	ton.APIClientWrapped
+	head              *ton.BlockIDExt
+	shards            []*ton.BlockIDExt
+	shardsErr         error
+	lookups           []uint32
+	cancel            context.CancelFunc
+	cancelAtLookupSeq uint32
+}
+
+func (f *fakeTonScannerAPI) CurrentMasterchainInfo(context.Context) (*ton.BlockIDExt, error) {
+	return f.head, nil
+}
+
+func (f *fakeTonScannerAPI) WaitForBlock(uint32) ton.APIClientWrapped {
+	return f
+}
+
+func (f *fakeTonScannerAPI) LookupBlock(_ context.Context, workchain int32, shard int64, seqno uint32) (*ton.BlockIDExt, error) {
+	f.lookups = append(f.lookups, seqno)
+	if f.cancel != nil && f.cancelAtLookupSeq == seqno {
+		f.cancel()
+	}
+	return &ton.BlockIDExt{
+		Workchain: workchain,
+		Shard:     shard,
+		SeqNo:     seqno,
+		RootHash:  bytes.Repeat([]byte{byte(seqno)}, 32),
+		FileHash:  bytes.Repeat([]byte{byte(seqno + 1)}, 32),
+	}, nil
+}
+
+func (f *fakeTonScannerAPI) GetBlockShardsInfo(context.Context, *ton.BlockIDExt) ([]*ton.BlockIDExt, error) {
+	if f.shardsErr != nil {
+		return nil, f.shardsErr
+	}
+	return f.shards, nil
+}
+
+func (f *fakeTonShardAPI) WaitForBlock(uint32) ton.APIClientWrapped {
+	return f
+}
+
+func (f *fakeTonShardAPI) GetBlockTransactionsV2(_ context.Context, block *ton.BlockIDExt, _ uint32, _ ...*ton.TransactionID3) ([]ton.TransactionShortInfo, bool, error) {
+	if block != nil {
+		f.fetchedShardSeqNos = append(f.fetchedShardSeqNos, block.SeqNo)
+	}
+	return f.blockShorts(block), f.incomplete, nil
+}
+
+func (f *fakeTonShardAPI) blockShorts(block *ton.BlockIDExt) []ton.TransactionShortInfo {
+	if block != nil && f.shortsByShardSeq != nil {
+		if shorts, ok := f.shortsByShardSeq[block.SeqNo]; ok {
+			return shorts
+		}
+	}
+	return f.shorts
+}
+
+func (f *fakeTonShardAPI) GetBlockShardsInfo(context.Context, *ton.BlockIDExt) ([]*ton.BlockIDExt, error) {
+	if f.shardsErr != nil {
+		return nil, f.shardsErr
+	}
+	return f.shards, nil
+}
+
+func (f *fakeTonShardAPI) LookupBlock(_ context.Context, workchain int32, shard int64, seqno uint32) (*ton.BlockIDExt, error) {
+	f.lookupSeqs = append(f.lookupSeqs, seqno)
+	if f.lookupBlocks != nil {
+		if block, ok := f.lookupBlocks[seqno]; ok {
+			return block, nil
+		}
+	}
+	return &ton.BlockIDExt{Workchain: workchain, Shard: shard, SeqNo: seqno}, nil
+}
+
+func (f *fakeTonShardAPI) GetTransaction(_ context.Context, _ *ton.BlockIDExt, addr *address.Address, lt uint64) (*tlb.Transaction, error) {
+	f.fetchedLTs = append(f.fetchedLTs, lt)
+	f.fetchedAddrs = append(f.fetchedAddrs, addressutil.TonRawAddressObjectKey(addr))
+	tx := f.txByLT[lt]
+	if tx == nil {
+		return nil, fmt.Errorf("missing tx lt=%d", lt)
+	}
+	return tx, nil
+}
+
+func seedTonScannerWallet(t *testing.T) {
+	t.Helper()
+	if _, err := data.AddWalletAddressWithNetwork(mdb.NetworkTon, "EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I"); err != nil {
+		t.Fatalf("seed TON wallet: %v", err)
+	}
+}
+
+func TestResolveTonLiteNodeSkipsCoolingPrimary(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	data.ResetRpcFailoverForTest()
+	t.Cleanup(data.ResetRpcFailoverForTest)
+
+	rows := []mdb.RpcNode{
+		{Network: mdb.NetworkTon, Url: " https://primary-ton.example.com/global.config.json ", Type: mdb.RpcNodeTypeLite, Weight: 100, Enabled: true, Purpose: mdb.RpcNodePurposeGeneral, Status: mdb.RpcNodeStatusOk},
+		{Network: mdb.NetworkTon, Url: "https://backup-ton.example.com/global.config.json", Type: mdb.RpcNodeTypeLite, Weight: 1, Enabled: true, Purpose: mdb.RpcNodePurposeGeneral, Status: mdb.RpcNodeStatusOk},
+		{Network: mdb.NetworkTon, Url: "https://manual-ton.example.com/global.config.json", Type: mdb.RpcNodeTypeLite, Weight: 1000, Enabled: true, Purpose: mdb.RpcNodePurposeManualVerify, Status: mdb.RpcNodeStatusOk},
+		{Network: mdb.NetworkTon, Url: "https://http-ton.example.com", Type: mdb.RpcNodeTypeHttp, Weight: 2000, Enabled: true, Purpose: mdb.RpcNodePurposeGeneral, Status: mdb.RpcNodeStatusOk},
+	}
+	if err := dao.Mdb.Create(&rows).Error; err != nil {
+		t.Fatalf("seed rpc_nodes: %v", err)
+	}
+
+	primary, ok := resolveTonLiteNode()
+	if !ok {
+		t.Fatalf("resolveTonLiteNode() ok=false, want true")
+	}
+	if primary.Url != "https://primary-ton.example.com/global.config.json" {
+		t.Fatalf("primary node = %#v, want trimmed primary lite node", primary)
+	}
+	for i := 0; i < data.RpcFailoverThreshold; i++ {
+		data.RecordRpcNodeFailure(primary.ID)
+	}
+
+	got, ok := resolveTonLiteNode()
+	if !ok {
+		t.Fatalf("resolveTonLiteNode() after cooldown ok=false, want true")
+	}
+	if got.Url != "https://backup-ton.example.com/global.config.json" {
+		t.Fatalf("resolveTonLiteNode() after cooldown = %#v, want backup lite node", got)
+	}
+}
+
+func TestRunTonScannerInitializesCursorAtCurrentHead(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	seedTonScannerWallet(t)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	api := &fakeTonScannerAPI{head: &ton.BlockIDExt{
+		Workchain: address.MasterchainID,
+		Shard:     tonMasterShard,
+		SeqNo:     77,
+		RootHash:  bytes.Repeat([]byte{0x77}, 32),
+		FileHash:  bytes.Repeat([]byte{0x78}, 32),
+	}}
+	cursor := &tonRuntimeCursor{}
+	if err := runTonScanner(ctx, api, newTonJettonWalletCache(), cursor); err != nil {
+		t.Fatalf("runTonScanner(): %v", err)
+	}
+	if !cursor.initialized {
+		t.Fatal("cursor not initialized")
+	}
+	if cursor.lastMasterSeqNo != 77 {
+		t.Fatalf("cursor seqno = %d, want 77", cursor.lastMasterSeqNo)
+	}
+	if len(api.lookups) != 0 {
+		t.Fatalf("initial cursor should not backfill, lookups=%#v", api.lookups)
+	}
+}
+
+func TestRunTonScannerIdleStatesPreserveInitializedCursor(t *testing.T) {
+	tests := []struct {
+		name  string
+		setup func(t *testing.T)
+	}{
+		{
+			name: "chain disabled",
+			setup: func(t *testing.T) {
+				t.Helper()
+				seedTonScannerWallet(t)
+				if err := data.UpdateChainFields(mdb.NetworkTon, map[string]interface{}{"enabled": false}); err != nil {
+					t.Fatalf("disable TON chain: %v", err)
+				}
+			},
+		},
+		{
+			name: "no enabled wallets",
+			setup: func(t *testing.T) {
+				t.Helper()
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cleanup := testutil.SetupTestDatabases(t)
+			defer cleanup()
+			tt.setup(t)
+
+			ctx, cancel := context.WithCancel(context.Background())
+			cancel()
+			api := &fakeTonScannerAPI{
+				head: &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 11},
+			}
+			cursor := &tonRuntimeCursor{initialized: true, lastMasterSeqNo: 10}
+			if err := runTonScanner(ctx, api, newTonJettonWalletCache(), cursor); err != nil {
+				t.Fatalf("runTonScanner(): %v", err)
+			}
+			if !cursor.initialized || cursor.lastMasterSeqNo != 10 {
+				t.Fatalf("cursor changed during idle state: initialized=%v seqno=%d, want initialized=true seqno=10", cursor.initialized, cursor.lastMasterSeqNo)
+			}
+		})
+	}
+}
+
+func TestRunTonScannerDoesNotAdvanceCursorOnMasterProcessingFailure(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	seedTonScannerWallet(t)
+
+	api := &fakeTonScannerAPI{
+		head:      &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 11},
+		shardsErr: errors.New("shard fetch failed"),
+	}
+	cursor := &tonRuntimeCursor{initialized: true, lastMasterSeqNo: 10}
+	err := runTonScanner(context.Background(), api, newTonJettonWalletCache(), cursor)
+	if err == nil {
+		t.Fatal("expected scanner failure")
+	}
+	if cursor.lastMasterSeqNo != 10 {
+		t.Fatalf("cursor advanced after failed block: %d, want 10", cursor.lastMasterSeqNo)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	api = &fakeTonScannerAPI{
+		head:   &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 11},
+		shards: nil,
+	}
+	if err := runTonScanner(ctx, api, newTonJettonWalletCache(), cursor); err != nil {
+		t.Fatalf("runTonScanner retry: %v", err)
+	}
+	if len(api.lookups) != 1 || api.lookups[0] != 11 {
+		t.Fatalf("retry lookups = %#v, want [11]", api.lookups)
+	}
+	if cursor.lastMasterSeqNo != 11 {
+		t.Fatalf("cursor seqno after retry = %d, want 11", cursor.lastMasterSeqNo)
+	}
+}
+
+func TestRunTonScannerDoesNotMarkCursorInitializedOnInitialShardFailure(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	seedTonScannerWallet(t)
+
+	api := &fakeTonScannerAPI{
+		head:      &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 11},
+		shardsErr: errors.New("initial shard fetch failed"),
+	}
+	cursor := &tonRuntimeCursor{}
+	err := runTonScanner(context.Background(), api, newTonJettonWalletCache(), cursor)
+	if err == nil {
+		t.Fatal("expected scanner failure")
+	}
+	if cursor.initialized {
+		t.Fatal("cursor was marked initialized after failed initial shard cursor setup")
+	}
+	if cursor.lastMasterSeqNo != 0 {
+		t.Fatalf("cursor master seqno = %d, want 0", cursor.lastMasterSeqNo)
+	}
+}
+
+func TestRunTonScannerRespectsMinConfirmations(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	seedTonScannerWallet(t)
+	if err := data.UpdateChainFields(mdb.NetworkTon, map[string]interface{}{"min_confirmations": 3}); err != nil {
+		t.Fatalf("set TON min confirmations: %v", err)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	api := &fakeTonScannerAPI{
+		head: &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 12},
+	}
+	cursor := &tonRuntimeCursor{initialized: true, lastMasterSeqNo: 10}
+	if err := runTonScanner(ctx, api, newTonJettonWalletCache(), cursor); err != nil {
+		t.Fatalf("runTonScanner(): %v", err)
+	}
+	if len(api.lookups) != 0 {
+		t.Fatalf("scanner processed unconfirmed blocks, lookups=%#v", api.lookups)
+	}
+	if cursor.lastMasterSeqNo != 10 {
+		t.Fatalf("cursor seqno = %d, want 10", cursor.lastMasterSeqNo)
+	}
+}
+
+func TestRunTonScannerCatchupProcessesAtMostFiftyMasterBlocksPerTick(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	seedTonScannerWallet(t)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	api := &fakeTonScannerAPI{
+		head:   &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 100},
+		shards: nil,
+	}
+	cursor := &tonRuntimeCursor{initialized: true, lastMasterSeqNo: 1}
+	if err := runTonScanner(ctx, api, newTonJettonWalletCache(), cursor); err != nil {
+		t.Fatalf("runTonScanner(): %v", err)
+	}
+	if len(api.lookups) != int(tonMaxMasterBlocksTick) {
+		t.Fatalf("lookup count = %d, want %d", len(api.lookups), tonMaxMasterBlocksTick)
+	}
+	if cursor.lastMasterSeqNo != 51 {
+		t.Fatalf("cursor seqno = %d, want 51", cursor.lastMasterSeqNo)
+	}
+}
+
+func TestRunTonScannerCatchupContinuesUntilConfirmedHead(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+	seedTonScannerWallet(t)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	api := &fakeTonScannerAPI{
+		head:              &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 60},
+		shards:            nil,
+		cancel:            cancel,
+		cancelAtLookupSeq: 60,
+	}
+	cursor := &tonRuntimeCursor{initialized: true, lastMasterSeqNo: 1}
+	if err := runTonScanner(ctx, api, newTonJettonWalletCache(), cursor); err != nil {
+		t.Fatalf("runTonScanner(): %v", err)
+	}
+	if len(api.lookups) != 59 {
+		t.Fatalf("lookup count = %d, want 59", len(api.lookups))
+	}
+	if api.lookups[0] != 2 || api.lookups[len(api.lookups)-1] != 60 {
+		t.Fatalf("lookups = %#v, want continuous 2..60", api.lookups)
+	}
+	for i, seq := range api.lookups {
+		want := uint32(i + 2)
+		if seq != want {
+			t.Fatalf("lookup[%d] = %d, want %d", i, seq, want)
+		}
+	}
+	if cursor.lastMasterSeqNo != 60 {
+		t.Fatalf("cursor seqno = %d, want 60", cursor.lastMasterSeqNo)
+	}
+}
+
+func TestProcessTonShardBlockFetchesOnlyWatchedWalletTransactions(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	receive := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	unwatched := address.NewAddress(0, byte(receive.Workchain()), bytes.Repeat([]byte{0x77}, 32)).Bounce(false).Testnet(false)
+	sender := address.NewAddress(0, byte(receive.Workchain()), bytes.Repeat([]byte{0x88}, 32)).Bounce(false).Testnet(false)
+
+	tx := &tlb.Transaction{
+		LT:   2,
+		Now:  uint32(time.Now().Unix()),
+		Hash: bytes.Repeat([]byte{0x99}, 32),
+		IO: struct {
+			In  *tlb.Message      `tlb:"maybe ^"`
+			Out *tlb.MessagesList `tlb:"maybe ^"`
+		}{
+			In: &tlb.Message{
+				MsgType: tlb.MsgTypeInternal,
+				Msg: &tlb.InternalMessage{
+					SrcAddr: sender,
+					DstAddr: receive,
+					Amount:  tlb.MustFromTON("1"),
+					Body:    cell.BeginCell().EndCell(),
+				},
+			},
+		},
+	}
+
+	api := &fakeTonShardAPI{
+		shorts: []ton.TransactionShortInfo{
+			{Account: unwatched.Data(), LT: 1, Hash: bytes.Repeat([]byte{0x01}, 32)},
+			{Account: receive.Data(), LT: 2, Hash: bytes.Repeat([]byte{0x02}, 32)},
+		},
+		txByLT: map[uint64]*tlb.Transaction{2: tx},
+	}
+	state := &tonWatchState{
+		wallets: map[string]*address.Address{
+			addressutil.TonRawAddressObjectKey(receive): receive,
+		},
+		nativeToken: &mdb.ChainToken{BaseModel: mdb.BaseModel{ID: 1}, Network: mdb.NetworkTon, Symbol: service.TonNativeSymbol, Decimals: 9, Enabled: true},
+	}
+
+	master := &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 10}
+	shard := &ton.BlockIDExt{Workchain: receive.Workchain(), Shard: 0, SeqNo: 9}
+	err := processTonShardBlock(context.Background(), api, master, shard, state, newTonJettonWalletCache())
+	if err != nil {
+		t.Fatalf("processTonShardBlock(): %v", err)
+	}
+	if len(api.fetchedLTs) != 1 || api.fetchedLTs[0] != 2 {
+		t.Fatalf("fetched LTs = %#v, want [2]", api.fetchedLTs)
+	}
+	if len(api.fetchedAddrs) != 1 || api.fetchedAddrs[0] != addressutil.TonRawAddressObjectKey(receive) {
+		t.Fatalf("fetched addresses = %#v, want watched receive address", api.fetchedAddrs)
+	}
+}
+
+func TestProcessTonMasterBlockWithCursorScansSkippedShardBlocks(t *testing.T) {
+	receive := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	sender := address.NewAddress(0, byte(receive.Workchain()), bytes.Repeat([]byte{0x88}, 32)).Bounce(false).Testnet(false)
+	txHash := bytes.Repeat([]byte{0x42}, 32)
+	tx := &tlb.Transaction{
+		LT:   88,
+		Now:  uint32(time.Now().Unix()),
+		Hash: txHash,
+		IO: struct {
+			In  *tlb.Message      `tlb:"maybe ^"`
+			Out *tlb.MessagesList `tlb:"maybe ^"`
+		}{
+			In: &tlb.Message{
+				MsgType: tlb.MsgTypeInternal,
+				Msg: &tlb.InternalMessage{
+					SrcAddr: sender,
+					DstAddr: receive,
+					Amount:  tlb.MustFromTON("1"),
+					Body:    cell.BeginCell().EndCell(),
+				},
+			},
+		},
+	}
+
+	currentShard := &ton.BlockIDExt{Workchain: receive.Workchain(), Shard: tonMasterShard, SeqNo: 89}
+	skippedShard := &ton.BlockIDExt{Workchain: receive.Workchain(), Shard: tonMasterShard, SeqNo: 88}
+	api := &fakeTonShardAPI{
+		shards:       []*ton.BlockIDExt{currentShard},
+		lookupBlocks: map[uint32]*ton.BlockIDExt{88: skippedShard},
+		shortsByShardSeq: map[uint32][]ton.TransactionShortInfo{
+			88: {{Account: receive.Data(), LT: tx.LT, Hash: txHash}},
+			89: nil,
+		},
+		txByLT: map[uint64]*tlb.Transaction{tx.LT: tx},
+	}
+	state := &tonWatchState{
+		wallets: map[string]*address.Address{
+			addressutil.TonRawAddressObjectKey(receive): receive,
+		},
+	}
+	cursorKey := tonShardCursorKey(currentShard)
+	cursor := &tonRuntimeCursor{
+		initialized:     true,
+		lastMasterSeqNo: 10,
+		shardSeqNo:      map[string]uint32{cursorKey: 87},
+	}
+
+	master := &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 10}
+	err := processTonMasterBlockWithCursor(context.Background(), api, master, state, newTonJettonWalletCache(), cursor)
+	if err != nil {
+		t.Fatalf("processTonMasterBlockWithCursor(): %v", err)
+	}
+	if len(api.lookupSeqs) != 1 || api.lookupSeqs[0] != 88 {
+		t.Fatalf("lookup shard seqs = %#v, want [88]", api.lookupSeqs)
+	}
+	if len(api.fetchedShardSeqNos) != 2 || api.fetchedShardSeqNos[0] != 88 || api.fetchedShardSeqNos[1] != 89 {
+		t.Fatalf("fetched shard seqs = %#v, want [88 89]", api.fetchedShardSeqNos)
+	}
+	if len(api.fetchedLTs) != 1 || api.fetchedLTs[0] != tx.LT {
+		t.Fatalf("fetched LTs = %#v, want [%d]", api.fetchedLTs, tx.LT)
+	}
+	if cursor.shardSeqNo[cursorKey] != 89 {
+		t.Fatalf("shard cursor = %d, want 89", cursor.shardSeqNo[cursorKey])
+	}
+}
+
+func TestProcessTonShardBlockMatchesJettonUSDTOrder(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	if err := data.SetSetting("rate", "rate.forced_rate_list", `{"cny":{"usdt":0.1}}`, "json"); err != nil {
+		t.Fatalf("set forced rate: %v", err)
+	}
+	receive := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	if _, err := data.AddWalletAddressWithNetwork(mdb.NetworkTon, receive.StringRaw()); err != nil {
+		t.Fatalf("add ton wallet: %v", err)
+	}
+	resp, err := service.CreateTransaction(&request.CreateTransactionRequest{
+		OrderId:   "order_ton_usdt_shard_1",
+		Currency:  "CNY",
+		Token:     "USDT",
+		Network:   mdb.NetworkTon,
+		Amount:    10,
+		NotifyUrl: "https://93.184.216.34/callback",
+	}, nil)
+	if err != nil {
+		t.Fatalf("create TON USDT order: %v", err)
+	}
+
+	sender := address.NewAddress(0, 0, bytes.Repeat([]byte{0x31}, 32)).Bounce(false).Testnet(false)
+	jettonWallet := address.NewAddress(0, byte(receive.Workchain()), bytes.Repeat([]byte{0x44}, 32)).Bounce(false).Testnet(false)
+	body, err := tlb.ToCell(jetton.TransferNotification{
+		QueryID:        7,
+		Amount:         tlb.MustFromNano(big.NewInt(1_000_000), 6),
+		Sender:         sender,
+		ForwardPayload: cell.BeginCell().EndCell(),
+	})
+	if err != nil {
+		t.Fatalf("build jetton notification body: %v", err)
+	}
+	tx := &tlb.Transaction{
+		LT:   22,
+		Now:  uint32(time.Now().Add(time.Second).Unix()),
+		Hash: bytes.Repeat([]byte{0x42}, 32),
+		IO: struct {
+			In  *tlb.Message      `tlb:"maybe ^"`
+			Out *tlb.MessagesList `tlb:"maybe ^"`
+		}{
+			In: &tlb.Message{
+				MsgType: tlb.MsgTypeInternal,
+				Msg: &tlb.InternalMessage{
+					SrcAddr: jettonWallet,
+					DstAddr: receive,
+					Amount:  tlb.FromNanoTONU(1),
+					Body:    body,
+				},
+			},
+		},
+	}
+
+	usdtMaster, err := addressutil.ParseTonMainnetAddress("0:b113a994b5024a16719f69139328eb759596c38a25f59028b146fecdc3621dfe")
+	if err != nil {
+		t.Fatalf("parse USDT jetton master: %v", err)
+	}
+	cache := newTonJettonWalletCache()
+	ownerRaw := addressutil.TonRawAddressObjectKey(receive)
+	cache.walletByOwnerToken[usdtMaster.Raw+"|"+ownerRaw] = addressutil.TonRawAddressObjectKey(jettonWallet)
+
+	api := &fakeTonShardAPI{
+		shorts: []ton.TransactionShortInfo{
+			{Account: receive.Data(), LT: tx.LT, Hash: tx.Hash},
+		},
+		txByLT: map[uint64]*tlb.Transaction{tx.LT: tx},
+	}
+	state := &tonWatchState{
+		wallets: map[string]*address.Address{
+			ownerRaw: receive,
+		},
+		jettonTokens: []mdb.ChainToken{
+			{BaseModel: mdb.BaseModel{ID: 2}, Network: mdb.NetworkTon, Symbol: "USDT", ContractAddress: usdtMaster.Raw, Decimals: 6, Enabled: true},
+		},
+	}
+	master := &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 10}
+	shard := &ton.BlockIDExt{Workchain: receive.Workchain(), Shard: 0, SeqNo: 9}
+	if err := processTonShardBlock(context.Background(), api, master, shard, state, cache); err != nil {
+		t.Fatalf("processTonShardBlock(): %v", err)
+	}
+
+	order, err := data.GetOrderInfoByTradeId(resp.TradeId)
+	if err != nil {
+		t.Fatalf("reload order: %v", err)
+	}
+	if order.Status != mdb.StatusPaySuccess {
+		t.Fatalf("order status = %d, want %d", order.Status, mdb.StatusPaySuccess)
+	}
+	wantBlockID := service.TonCanonicalBlockTransactionID(receive.StringRaw(), tx.LT, hex.EncodeToString(tx.Hash))
+	if order.BlockTransactionId != wantBlockID {
+		t.Fatalf("block transaction id = %q, want %q", order.BlockTransactionId, wantBlockID)
+	}
+	lock, err := data.GetTradeIdByWalletAddressAndAmountAndToken(mdb.NetworkTon, receive.StringRaw(), "USDT", resp.ActualAmount)
+	if err != nil {
+		t.Fatalf("lookup TON USDT lock: %v", err)
+	}
+	if lock != "" {
+		t.Fatalf("TON USDT lock still exists after shard processing: %s", lock)
+	}
+}
+
+func TestProcessTonMasterBlockScansMasterchainWalletTransactions(t *testing.T) {
+	cleanup := testutil.SetupTestDatabases(t)
+	defer cleanup()
+
+	masterchainID := address.MasterchainID
+	masterchainByte := byte(int8(masterchainID))
+	receive := address.NewAddress(0, masterchainByte, bytes.Repeat([]byte{0x66}, 32)).Bounce(false).Testnet(false)
+	sender := address.NewAddress(0, masterchainByte, bytes.Repeat([]byte{0x88}, 32)).Bounce(false).Testnet(false)
+	tx := &tlb.Transaction{
+		LT:   2,
+		Now:  uint32(time.Now().Unix()),
+		Hash: bytes.Repeat([]byte{0x99}, 32),
+		IO: struct {
+			In  *tlb.Message      `tlb:"maybe ^"`
+			Out *tlb.MessagesList `tlb:"maybe ^"`
+		}{
+			In: &tlb.Message{
+				MsgType: tlb.MsgTypeInternal,
+				Msg: &tlb.InternalMessage{
+					SrcAddr: sender,
+					DstAddr: receive,
+					Amount:  tlb.MustFromTON("1"),
+					Body:    cell.BeginCell().EndCell(),
+				},
+			},
+		},
+	}
+	api := &fakeTonShardAPI{
+		shorts: []ton.TransactionShortInfo{
+			{Account: receive.Data(), LT: 2, Hash: bytes.Repeat([]byte{0x02}, 32)},
+		},
+		txByLT: map[uint64]*tlb.Transaction{2: tx},
+	}
+	state := &tonWatchState{
+		wallets: map[string]*address.Address{
+			addressutil.TonRawAddressObjectKey(receive): receive,
+		},
+		nativeToken: &mdb.ChainToken{BaseModel: mdb.BaseModel{ID: 1}, Network: mdb.NetworkTon, Symbol: service.TonNativeSymbol, Decimals: 9, Enabled: true},
+	}
+
+	master := &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 10}
+	if err := processTonMasterBlock(context.Background(), api, master, state, newTonJettonWalletCache()); err != nil {
+		t.Fatalf("processTonMasterBlock(): %v", err)
+	}
+	if len(api.fetchedLTs) != 1 || api.fetchedLTs[0] != 2 {
+		t.Fatalf("fetched LTs = %#v, want [2]", api.fetchedLTs)
+	}
+	if len(api.fetchedAddrs) != 1 || api.fetchedAddrs[0] != addressutil.TonRawAddressObjectKey(receive) {
+		t.Fatalf("fetched addresses = %#v, want masterchain receive address", api.fetchedAddrs)
+	}
+}
+
+func TestProcessTonShardBlockFailsOnIncompleteEmptyPage(t *testing.T) {
+	api := &fakeTonShardAPI{incomplete: true}
+	state := &tonWatchState{wallets: map[string]*address.Address{}}
+	master := &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 10}
+	shard := &ton.BlockIDExt{Workchain: 0, Shard: 0, SeqNo: 9}
+
+	err := processTonShardBlock(context.Background(), api, master, shard, state, newTonJettonWalletCache())
+	if err == nil {
+		t.Fatal("expected incomplete empty page error")
+	}
+}
+
+func TestProcessTonShardBlockFailsWhenJettonWalletsCannotBeResolved(t *testing.T) {
+	receive := address.MustParseAddr("EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I")
+	sender := address.NewAddress(0, byte(receive.Workchain()), bytes.Repeat([]byte{0x88}, 32)).Bounce(false).Testnet(false)
+	tx := &tlb.Transaction{
+		LT:   2,
+		Now:  uint32(time.Now().Unix()),
+		Hash: bytes.Repeat([]byte{0x99}, 32),
+		IO: struct {
+			In  *tlb.Message      `tlb:"maybe ^"`
+			Out *tlb.MessagesList `tlb:"maybe ^"`
+		}{
+			In: &tlb.Message{
+				MsgType: tlb.MsgTypeInternal,
+				Msg: &tlb.InternalMessage{
+					SrcAddr: sender,
+					DstAddr: receive,
+					Amount:  tlb.MustFromTON("1"),
+					Body:    cell.BeginCell().EndCell(),
+				},
+			},
+		},
+	}
+	api := &fakeTonShardAPI{
+		shorts: []ton.TransactionShortInfo{
+			{Account: receive.Data(), LT: 2, Hash: bytes.Repeat([]byte{0x02}, 32)},
+		},
+		txByLT: map[uint64]*tlb.Transaction{2: tx},
+	}
+	state := &tonWatchState{
+		wallets: map[string]*address.Address{
+			addressutil.TonRawAddressObjectKey(receive): receive,
+		},
+		jettonTokens: []mdb.ChainToken{
+			{BaseModel: mdb.BaseModel{ID: 1}, Network: mdb.NetworkTon, Symbol: "USDT", ContractAddress: "not-a-ton-address", Decimals: 6, Enabled: true},
+		},
+	}
+
+	master := &ton.BlockIDExt{Workchain: address.MasterchainID, Shard: tonMasterShard, SeqNo: 10}
+	shard := &ton.BlockIDExt{Workchain: receive.Workchain(), Shard: 0, SeqNo: 9}
+	err := processTonShardBlock(context.Background(), api, master, shard, state, newTonJettonWalletCache())
+	if err == nil {
+		t.Fatal("expected jetton wallet resolution failure")
+	}
+	if len(api.fetchedLTs) != 1 || api.fetchedLTs[0] != 2 {
+		t.Fatalf("fetched LTs = %#v, want [2]", api.fetchedLTs)
+	}
+}

src/telegram/utils.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/GMWalletApp/epusdt/model/mdb"
+	addressutil "github.com/GMWalletApp/epusdt/util/address"
 	"github.com/btcsuite/btcutil/base58"
 	"github.com/gagliardetto/solana-go"
 )
@@ -53,6 +54,9 @@ func isValidAddressByNetwork(network, addr string) bool {
 		return isValidTronAddress(addr)
 	case mdb.NetworkSolana:
 		return isValidSolanaAddress(addr)
+	case mdb.NetworkTon:
+		_, err := addressutil.ParseTonMainnetAddress(addr)
+		return err == nil
 	default:
 		// 其余 EVM 链统一使用 0x 地址校验
 		return isValidEthereumAddress(addr)
@@ -64,6 +68,11 @@ func normalizeWalletAddressByNetwork(network, addr string) string {
 	switch strings.ToLower(strings.TrimSpace(network)) {
 	case mdb.NetworkTron, mdb.NetworkSolana:
 		return addr
+	case mdb.NetworkTon:
+		if normalized, err := addressutil.NormalizeTonAddress(addr); err == nil {
+			return normalized
+		}
+		return addr
 	default:
 		return strings.ToLower(addr)
 	}

src/util/address/move.go

@@ -0,0 +1,67 @@
+package addressutil
+
+import (
+	"encoding/hex"
+	"fmt"
+	"strings"
+)
+
+// NormalizeMoveAddress returns the canonical 0x-prefixed, 64-hex-character
+// account address used by Aptos.
+func NormalizeMoveAddress(input string) (string, error) {
+	raw := strings.ToLower(strings.TrimSpace(input))
+	raw = strings.TrimPrefix(raw, "0x")
+	if raw == "" {
+		return "", fmt.Errorf("move address is empty")
+	}
+	if len(raw) > 64 {
+		return "", fmt.Errorf("move address is too long")
+	}
+	if _, err := hex.DecodeString(padEvenHex(raw)); err != nil {
+		return "", fmt.Errorf("invalid move address")
+	}
+	return "0x" + strings.Repeat("0", 64-len(raw)) + raw, nil
+}
+
+func padEvenHex(raw string) string {
+	if len(raw)%2 == 0 {
+		return raw
+	}
+	return "0" + raw
+}
+
+// NormalizeMoveAssetID canonicalizes Move asset identifiers used in
+// chain_tokens.contract_address for Aptos. A plain address is normalized to
+// 64 hex chars; structured types keep module/name suffixes after normalizing
+// the leading address.
+func NormalizeMoveAssetID(input string) string {
+	raw := strings.ToLower(strings.TrimSpace(input))
+	if raw == "" {
+		return ""
+	}
+	parts := strings.Split(raw, "::")
+	if len(parts) == 1 {
+		if addr, err := NormalizeMoveAddress(raw); err == nil {
+			return addr
+		}
+		return raw
+	}
+	if addr, err := NormalizeMoveAddress(parts[0]); err == nil {
+		parts[0] = addr
+	}
+	return strings.Join(parts, "::")
+}
+
+func MoveAssetMatches(observed, configured string) bool {
+	observed = NormalizeMoveAssetID(observed)
+	configured = NormalizeMoveAssetID(configured)
+	if configured == "" {
+		return observed == ""
+	}
+	if observed == configured {
+		return true
+	}
+	// Aptos FA event payloads may expose only the metadata address while other
+	// payloads expose a type string containing the same address.
+	return strings.Contains(observed, configured)
+}

src/util/address/move_test.go

@@ -0,0 +1,42 @@
+package addressutil
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestNormalizeMoveAddress(t *testing.T) {
+	got, err := NormalizeMoveAddress(" A ")
+	if err != nil {
+		t.Fatalf("NormalizeMoveAddress: %v", err)
+	}
+	want := "0x000000000000000000000000000000000000000000000000000000000000000a"
+	if got != want {
+		t.Fatalf("address = %q, want %q", got, want)
+	}
+
+	got, err = NormalizeMoveAddress("0X" + "ABCDEF")
+	if err != nil {
+		t.Fatalf("NormalizeMoveAddress uppercase: %v", err)
+	}
+	want = "0x0000000000000000000000000000000000000000000000000000000000abcdef"
+	if got != want {
+		t.Fatalf("uppercase address = %q, want %q", got, want)
+	}
+}
+
+func TestNormalizeMoveAddressRejectsInvalid(t *testing.T) {
+	for _, input := range []string{"", "0xzz", "0x" + strings.Repeat("1", 65)} {
+		if _, err := NormalizeMoveAddress(input); err == nil {
+			t.Fatalf("NormalizeMoveAddress(%q) succeeded, want error", input)
+		}
+	}
+}
+
+func TestNormalizeMoveAssetIDNormalizesLeadingAddress(t *testing.T) {
+	got := NormalizeMoveAssetID("0X1::FUNGIBLE_ASSET::METADATA")
+	want := "0x0000000000000000000000000000000000000000000000000000000000000001::fungible_asset::metadata"
+	if got != want {
+		t.Fatalf("asset id = %q, want %q", got, want)
+	}
+}

src/util/address/ton.go

@@ -0,0 +1,135 @@
+package addressutil
+
+import (
+	"encoding/base64"
+	"encoding/binary"
+	"fmt"
+	"strings"
+
+	"github.com/xssnick/tonutils-go/address"
+	"github.com/xssnick/tonutils-go/crc16"
+)
+
+// TonParsedAddress carries the canonical display and raw forms used by epusdt.
+type TonParsedAddress struct {
+	Address *address.Address
+	Display string
+	Raw     string
+}
+
+// ParseTonMainnetAddress accepts raw and user-friendly TON addresses and rejects
+// user-friendly testnet-only addresses. Raw addresses do not contain a testnet
+// flag, so they are treated as mainnet addresses by definition.
+func ParseTonMainnetAddress(input string) (*TonParsedAddress, error) {
+	raw := strings.TrimSpace(input)
+	if raw == "" {
+		return nil, fmt.Errorf("ton address is empty")
+	}
+
+	var (
+		addr       *address.Address
+		err        error
+		checkFlags bool
+	)
+	if strings.Contains(raw, ":") {
+		addr, err = address.ParseRawAddr(raw)
+	} else {
+		addr, err = parseUserFriendly(raw)
+		checkFlags = true
+	}
+	if err != nil {
+		return nil, err
+	}
+	if addr == nil || addr.Type() != address.StdAddress || addr.IsAddrNone() {
+		return nil, fmt.Errorf("unsupported ton address type")
+	}
+	if checkFlags && addr.IsTestnetOnly() {
+		return nil, fmt.Errorf("testnet-only ton address is not supported")
+	}
+
+	mainnet := addr.Bounce(false).Testnet(false)
+	return &TonParsedAddress{
+		Address: mainnet,
+		Display: mainnet.String(),
+		Raw:     strings.ToLower(mainnet.StringRaw()),
+	}, nil
+}
+
+// NormalizeTonAddress returns the canonical user-friendly address stored in DB.
+func NormalizeTonAddress(input string) (string, error) {
+	parsed, err := ParseTonMainnetAddress(input)
+	if err != nil {
+		return "", err
+	}
+	return parsed.Display, nil
+}
+
+// TonRawAddressKey returns the workchain:hash key used for comparisons and locks.
+func TonRawAddressKey(input string) (string, error) {
+	parsed, err := ParseTonMainnetAddress(input)
+	if err != nil {
+		return "", err
+	}
+	return parsed.Raw, nil
+}
+
+// NormalizeTonAddressObject returns the canonical user-friendly form for a parsed
+// address object.
+func NormalizeTonAddressObject(addr *address.Address) string {
+	if addr == nil {
+		return ""
+	}
+	return addr.Bounce(false).Testnet(false).String()
+}
+
+// TonRawAddressObjectKey returns the raw workchain:hash key for a parsed address.
+func TonRawAddressObjectKey(addr *address.Address) string {
+	if addr == nil {
+		return ""
+	}
+	return strings.ToLower(addr.Bounce(false).Testnet(false).StringRaw())
+}
+
+// TonAddressFromShortAccount builds a standard TON address from a shard
+// transaction account id returned by liteserver block transaction lists.
+func TonAddressFromShortAccount(workchain int32, account []byte) *address.Address {
+	if len(account) != 32 {
+		return nil
+	}
+	return address.NewAddress(0, byte(workchain), append([]byte(nil), account...)).Bounce(false).Testnet(false)
+}
+
+func parseUserFriendly(input string) (*address.Address, error) {
+	if addr, err := address.ParseAddr(input); err == nil {
+		return addr, nil
+	}
+	for _, enc := range []*base64.Encoding{
+		base64.RawStdEncoding,
+		base64.StdEncoding,
+		base64.URLEncoding,
+	} {
+		data, err := enc.DecodeString(input)
+		if err != nil {
+			continue
+		}
+		addr, err := addressFromFriendlyBytes(data)
+		if err == nil {
+			return addr, nil
+		}
+	}
+	return nil, fmt.Errorf("invalid ton address")
+}
+
+func addressFromFriendlyBytes(data []byte) (*address.Address, error) {
+	if len(data) != 36 {
+		return nil, fmt.Errorf("incorrect ton address data length")
+	}
+	want := binary.BigEndian.Uint16(data[34:])
+	if crc16.ChecksumXMODEM(data[:34]) != want {
+		return nil, fmt.Errorf("invalid ton address checksum")
+	}
+	if len(data[2:34]) != 32 {
+		return nil, fmt.Errorf("incorrect ton address hash length")
+	}
+	return address.NewAddress(data[0], data[1], append([]byte(nil), data[2:34]...)), nil
+}

src/util/address/ton_test.go

@@ -0,0 +1,56 @@
+package addressutil
+
+import (
+	"encoding/base64"
+	"strings"
+	"testing"
+
+	"github.com/xssnick/tonutils-go/address"
+)
+
+const testTonBounceable = "EQC6KV4zs8TJtSZapOrRFmqSkxzpq-oSCoxekQRKElf4nC1I"
+
+func TestParseTonMainnetAddressNormalizesSupportedFormats(t *testing.T) {
+	base := address.MustParseAddr(testTonBounceable)
+	raw := base.StringRaw()
+	nonBounce := base.Bounce(false).String()
+	rawBytes, err := base64.RawURLEncoding.DecodeString(testTonBounceable)
+	if err != nil {
+		t.Fatalf("decode fixture: %v", err)
+	}
+	stdBase64 := base64.RawStdEncoding.EncodeToString(rawBytes)
+
+	for _, input := range []string{testTonBounceable, nonBounce, raw, stdBase64} {
+		parsed, err := ParseTonMainnetAddress(input)
+		if err != nil {
+			t.Fatalf("ParseTonMainnetAddress(%q): %v", input, err)
+		}
+		if parsed.Display != nonBounce {
+			t.Fatalf("display for %q = %q, want %q", input, parsed.Display, nonBounce)
+		}
+		if parsed.Raw != strings.ToLower(raw) {
+			t.Fatalf("raw for %q = %q, want %q", input, parsed.Raw, strings.ToLower(raw))
+		}
+	}
+}
+
+func TestParseTonMainnetAddressRejectsTestnetOnly(t *testing.T) {
+	testnet := address.MustParseAddr(testTonBounceable).Testnet(true).String()
+	if _, err := ParseTonMainnetAddress(testnet); err == nil {
+		t.Fatal("expected testnet-only address to be rejected")
+	}
+}
+
+func TestTonAddressFromShortAccount(t *testing.T) {
+	base := address.MustParseAddr(testTonBounceable)
+	got := TonAddressFromShortAccount(base.Workchain(), base.Data())
+	if got == nil {
+		t.Fatal("TonAddressFromShortAccount() returned nil")
+	}
+	if TonRawAddressObjectKey(got) != TonRawAddressObjectKey(base) {
+		t.Fatalf("raw address = %q, want %q", TonRawAddressObjectKey(got), TonRawAddressObjectKey(base))
+	}
+	if got = TonAddressFromShortAccount(base.Workchain(), base.Data()[:31]); got != nil {
+		t.Fatalf("TonAddressFromShortAccount() with short account = %#v, want nil", got)
+	}
+}

src/util/constant/errno.go

@@ -47,6 +47,9 @@ var Errno = map[int]string{
 	10041: "invalid notify url",
 	10042: "payment provider order creation failed",
 	10043: "invalid setting item",
+	10044: "invalid order redirect url",
+	10045: "order api key unavailable",
+	10046: "failed to build epay return signature",
 }
 
 var (
@@ -94,6 +97,9 @@ var (
 	NotifyURLErr               = Err(10041)
 	PaymentProviderCreateErr   = Err(10042)
 	SettingItemErr             = Err(10043)
+	OrderRedirectURLErr        = Err(10044)
+	OrderApiKeyUnavailableErr  = Err(10045)
+	EPayReturnSignatureErr     = Err(10046)
 )
 
 type RspError struct {

src/util/log/log.go

@@ -2,6 +2,9 @@ package log
 
 import (
 	"fmt"
+	"strings"
+	"sync"
+
 	"github.com/GMWalletApp/epusdt/config"
 	"github.com/natefinch/lumberjack"
 	"github.com/spf13/viper"
@@ -13,11 +16,16 @@ import (
 
 var Sugar *zap.SugaredLogger
 
+var (
+	atomicLevel = zap.NewAtomicLevelAt(zapcore.InfoLevel)
+	levelMu     sync.Mutex
+)
+
 func Init() {
-	level := getLogLevel()
+	atomicLevel.SetLevel(getLogLevel())
 	core := zapcore.NewTee(
-		zapcore.NewCore(getConsoleEncoder(), getConsoleWriter(), level),
+		zapcore.NewCore(getConsoleEncoder(), getConsoleWriter(), atomicLevel),
-		zapcore.NewCore(getFileEncoder(), getFileWriter(), level),
+		zapcore.NewCore(getFileEncoder(), getFileWriter(), atomicLevel),
 	)
 	logger := zap.New(core, zap.AddCaller())
 	Sugar = logger.Sugar()
@@ -56,14 +64,75 @@ func getConsoleWriter() zapcore.WriteSyncer {
 }
 
 func getLogLevel() zapcore.Level {
-	switch config.LogLevel {
+	level, _, err := parseLevel(config.LogLevel)
-	case "debug":
+	if err != nil {
-		return zapcore.DebugLevel
-	case "warn":
-		return zapcore.WarnLevel
-	case "error":
-		return zapcore.ErrorLevel
-	default:
 		return zapcore.InfoLevel
 	}
+	return level
+}
+
+func SetLevel(level string) error {
+	nextLevel, normalized, err := parseLevel(level)
+	if err != nil {
+		return err
+	}
+
+	levelMu.Lock()
+	defer levelMu.Unlock()
+
+	currentLevel := atomicLevel.Level()
+	current := levelToString(currentLevel)
+	if current == normalized {
+		return nil
+	}
+
+	message := fmt.Sprintf("[log] level changed: %s -> %s", current, normalized)
+	if Sugar != nil && currentLevel <= zapcore.WarnLevel {
+		Sugar.Warn(message)
+	}
+	atomicLevel.SetLevel(nextLevel)
+	if Sugar != nil && currentLevel > zapcore.WarnLevel {
+		Sugar.Warn(message)
+	}
+	return nil
+}
+
+func CurrentLevel() string {
+	return levelToString(atomicLevel.Level())
+}
+
+func NormalizeLevel(level string) (string, error) {
+	_, normalized, err := parseLevel(level)
+	return normalized, err
+}
+
+func parseLevel(level string) (zapcore.Level, string, error) {
+	normalized := strings.ToLower(strings.TrimSpace(level))
+	switch normalized {
+	case "debug":
+		return zapcore.DebugLevel, normalized, nil
+	case "info":
+		return zapcore.InfoLevel, normalized, nil
+	case "warn":
+		return zapcore.WarnLevel, normalized, nil
+	case "error":
+		return zapcore.ErrorLevel, normalized, nil
+	default:
+		return zapcore.InfoLevel, "", fmt.Errorf("unsupported log level %q", level)
+	}
+}
+
+func levelToString(level zapcore.Level) string {
+	switch level {
+	case zapcore.DebugLevel:
+		return "debug"
+	case zapcore.InfoLevel:
+		return "info"
+	case zapcore.WarnLevel:
+		return "warn"
+	case zapcore.ErrorLevel:
+		return "error"
+	default:
+		return level.String()
+	}
 }

src/util/log/log_test.go

@@ -0,0 +1,45 @@
+package log
+
+import (
+	"testing"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"go.uber.org/zap/zaptest/observer"
+)
+
+func TestSetLevelUpdatesAtomicLevelAndLogsChange(t *testing.T) {
+	oldSugar := Sugar
+	oldLevel := atomicLevel.Level()
+	t.Cleanup(func() {
+		Sugar = oldSugar
+		atomicLevel.SetLevel(oldLevel)
+	})
+
+	core, observed := observer.New(zapcore.WarnLevel)
+	Sugar = zap.New(core).Sugar()
+	atomicLevel.SetLevel(zapcore.ErrorLevel)
+
+	if err := SetLevel(" DEBUG "); err != nil {
+		t.Fatalf("SetLevel(DEBUG): %v", err)
+	}
+	if got := CurrentLevel(); got != "debug" {
+		t.Fatalf("CurrentLevel = %q, want debug", got)
+	}
+	logs := observed.FilterMessage("[log] level changed: error -> debug").All()
+	if len(logs) != 1 {
+		t.Fatalf("level change logs = %d, want 1; all=%v", len(logs), observed.All())
+	}
+
+	if err := SetLevel("debug"); err != nil {
+		t.Fatalf("SetLevel(debug no-op): %v", err)
+	}
+	logs = observed.FilterMessage("[log] level changed: error -> debug").All()
+	if len(logs) != 1 {
+		t.Fatalf("no-op level change emitted extra logs: %d", len(logs))
+	}
+
+	if err := SetLevel("fatal"); err == nil {
+		t.Fatal("SetLevel(fatal) succeeded, want error")
+	}
+}

src/www/assets/401-BxmwY4ZX.js

@@ -0,0 +1 @@
+import{t as e}from"./unauthorized-error-B6bKLdq-.js";var t=e;export{t as component};

src/www/assets/401-CgiW3IHf.js

@@ -1 +0,0 @@
-import{t as e}from"./unauthorized-error-Dv-DRB5e.js";var t=e;export{t as component};

src/www/assets/403-DROJKVmF.js

@@ -0,0 +1 @@
+import{t as e}from"./forbidden-DZPSchCU.js";var t=e;export{t as component};

src/www/assets/403-Dtxfafe8.js

@@ -1 +0,0 @@
-import{t as e}from"./forbidden-CHYUR1RB.js";var t=e;export{t as component};

src/www/assets/404-CfnT1SCK.js

@@ -0,0 +1 @@
+import{t as e}from"./not-found-error-CHHM1I1c.js";var t=e;export{t as component};

src/www/assets/404-CyPqWH-N.js

@@ -1 +0,0 @@
-import{t as e}from"./not-found-error-AnL_Yh5s.js";var t=e;export{t as component};

src/www/assets/500-CHTSz3Mz.js

@@ -1 +0,0 @@
-import{t as e}from"./general-error-CkWgD-Kh.js";var t=e;export{t as component};

src/www/assets/500-Ckr9SgA0.js

@@ -0,0 +1 @@
+import{t as e}from"./general-error-BoIfl_4Z.js";var t=e;export{t as component};

src/www/assets/503-CohoD9dT.js

@@ -1 +0,0 @@
-import{t as e}from"./maintenance-error-CpldkShG.js";var t=e;export{t as component};

src/www/assets/503-KDAPoK8D.js

@@ -0,0 +1 @@
+import{t as e}from"./maintenance-error-CuCw7L8t.js";var t=e;export{t as component};

src/www/assets/Matches-DYR79wJf.js

@@ -1 +1 @@
-import{r as e}from"./chunk-DECur_0Z.js";import{t}from"./react-CO2uhaBc.js";import{Pp as n}from"./messages-d1hRBHLP.js";import{o as r,s as i,t as a}from"./useRouter-DtTm7XkK.js";import{t as o}from"./useStore-CupyIEEP.js";import{f as s}from"./ClientOnly-CMPEj0pJ.js";import"./redirect-DMNGvjzO.js";import{a as c,i as l,r as u,s as d,t as f}from"./Match-9UShCljL.js";import{n as p}from"./matchContext-BFCdcHzo.js";import{t as m}from"./atom-DQpaPCwp.js";function h(e){if(typeof document<`u`&&document.querySelector){let t=e.stores.location.get(),n=t.state.__hashScrollIntoViewOptions??!0;if(n&&t.hash!==``){let e=document.getElementById(t.hash);e&&e.scrollIntoView(n)}}}var g=e(t(),1);function _(){let e=a(),t=g.useRef({router:e,mounted:!1}),[n,c]=g.useState(!1),l=o(e.stores.isLoading,e=>e),u=o(e.stores.hasPending,e=>e),f=i(l),p=l||n||u,_=i(p),v=l||u,y=i(v);return e.startTransition=e=>{c(!0),g.startTransition(()=>{e(),c(!1)})},g.useEffect(()=>{let t=e.history.subscribe(e.load),n=e.buildLocation({to:e.latestLocation.pathname,search:!0,params:!0,hash:!0,state:!0,_includeValidateSearch:!0});return s(e.latestLocation.publicHref)!==s(n.publicHref)&&e.commitLocation({...n,replace:!0}),()=>{t()}},[e,e.history]),r(()=>{typeof window<`u`&&e.ssr||t.current.router===e&&t.current.mounted||(t.current={router:e,mounted:!0},(async()=>{try{await e.load()}catch(e){console.error(e)}})())},[e]),r(()=>{f&&!l&&e.emit({type:`onLoad`,...d(e.stores.location.get(),e.stores.resolvedLocation.get())})},[f,e,l]),r(()=>{y&&!v&&e.emit({type:`onBeforeRouteMount`,...d(e.stores.location.get(),e.stores.resolvedLocation.get())})},[v,y,e]),r(()=>{if(_&&!p){let t=d(e.stores.location.get(),e.stores.resolvedLocation.get());e.emit({type:`onResolved`,...t}),m(()=>{e.stores.status.set(`idle`),e.stores.resolvedLocation.set(e.stores.location.get())}),t.hrefChanged&&h(e)}},[p,_,e]),null}var v=n();function y(){let e=a(),t=e.routesById.__root__.options.pendingComponent??e.options.defaultPendingComponent,n=t?(0,v.jsx)(t,{}):null,r=(0,v.jsxs)(typeof document<`u`&&e.ssr?u:g.Suspense,{fallback:n,children:[(0,v.jsx)(_,{}),(0,v.jsx)(b,{})]});return e.options.InnerWrap?(0,v.jsx)(e.options.InnerWrap,{children:r}):r}function b(){let e=a(),t=o(e.stores.firstId,e=>e),n=o(e.stores.loadedAt,e=>e),r=t?(0,v.jsx)(f,{matchId:t}):null;return(0,v.jsx)(p.Provider,{value:t,children:e.options.disableGlobalCatchBoundary?r:(0,v.jsx)(l,{getResetKey:()=>n,errorComponent:c,onCatch:void 0,children:r})})}function x(){let e=a();return o(e.stores.matchRouteDeps,e=>e),g.useCallback(t=>{let{pending:n,caseSensitive:r,fuzzy:i,includeSearch:a,...o}=t;return e.matchRoute(o,{pending:n,caseSensitive:r,fuzzy:i,includeSearch:a})},[e])}export{x as n,y as t};
+import{r as e}from"./chunk-DECur_0Z.js";import{t}from"./react-CO2uhaBc.js";import{em as n}from"./messages-Bp0bCjzp.js";import{o as r,s as i,t as a}from"./useRouter-DtTm7XkK.js";import{t as o}from"./useStore-CupyIEEP.js";import{f as s}from"./ClientOnly-fFIveJVd.js";import"./redirect-DMNGvjzO.js";import{a as c,i as l,r as u,s as d,t as f}from"./Match-Cm64cgS9.js";import{n as p}from"./matchContext-BFCdcHzo.js";import{t as m}from"./atom-DQpaPCwp.js";function h(e){if(typeof document<`u`&&document.querySelector){let t=e.stores.location.get(),n=t.state.__hashScrollIntoViewOptions??!0;if(n&&t.hash!==``){let e=document.getElementById(t.hash);e&&e.scrollIntoView(n)}}}var g=e(t(),1);function _(){let e=a(),t=g.useRef({router:e,mounted:!1}),[n,c]=g.useState(!1),l=o(e.stores.isLoading,e=>e),u=o(e.stores.hasPending,e=>e),f=i(l),p=l||n||u,_=i(p),v=l||u,y=i(v);return e.startTransition=e=>{c(!0),g.startTransition(()=>{e(),c(!1)})},g.useEffect(()=>{let t=e.history.subscribe(e.load),n=e.buildLocation({to:e.latestLocation.pathname,search:!0,params:!0,hash:!0,state:!0,_includeValidateSearch:!0});return s(e.latestLocation.publicHref)!==s(n.publicHref)&&e.commitLocation({...n,replace:!0}),()=>{t()}},[e,e.history]),r(()=>{typeof window<`u`&&e.ssr||t.current.router===e&&t.current.mounted||(t.current={router:e,mounted:!0},(async()=>{try{await e.load()}catch(e){console.error(e)}})())},[e]),r(()=>{f&&!l&&e.emit({type:`onLoad`,...d(e.stores.location.get(),e.stores.resolvedLocation.get())})},[f,e,l]),r(()=>{y&&!v&&e.emit({type:`onBeforeRouteMount`,...d(e.stores.location.get(),e.stores.resolvedLocation.get())})},[v,y,e]),r(()=>{if(_&&!p){let t=d(e.stores.location.get(),e.stores.resolvedLocation.get());e.emit({type:`onResolved`,...t}),m(()=>{e.stores.status.set(`idle`),e.stores.resolvedLocation.set(e.stores.location.get())}),t.hrefChanged&&h(e)}},[p,_,e]),null}var v=n();function y(){let e=a(),t=e.routesById.__root__.options.pendingComponent??e.options.defaultPendingComponent,n=t?(0,v.jsx)(t,{}):null,r=(0,v.jsxs)(typeof document<`u`&&e.ssr?u:g.Suspense,{fallback:n,children:[(0,v.jsx)(_,{}),(0,v.jsx)(b,{})]});return e.options.InnerWrap?(0,v.jsx)(e.options.InnerWrap,{children:r}):r}function b(){let e=a(),t=o(e.stores.firstId,e=>e),n=o(e.stores.loadedAt,e=>e),r=t?(0,v.jsx)(f,{matchId:t}):null;return(0,v.jsx)(p.Provider,{value:t,children:e.options.disableGlobalCatchBoundary?r:(0,v.jsx)(l,{getResetKey:()=>n,errorComponent:c,onCatch:void 0,children:r})})}function x(){let e=a();return o(e.stores.matchRouteDeps,e=>e),g.useCallback(t=>{let{pending:n,caseSensitive:r,fuzzy:i,includeSearch:a,...o}=t;return e.matchRoute(o,{pending:n,caseSensitive:r,fuzzy:i,includeSearch:a})},[e])}export{x as n,y as t};

src/www/assets/_.contribution-CaUqztrQ.js

@@ -1 +1 @@
-import{h as e}from"./editor.api2-BpueNIaM.js";import"./toggleHighContrast-DRztGxhw.js";var t={},n={},r=class e{static getOrCreate(t){return n[t]||(n[t]=new e(t)),n[t]}constructor(e){this._languageId=e,this._loadingTriggered=!1,this._lazyLoadPromise=new Promise((e,t)=>{this._lazyLoadPromiseResolve=e,this._lazyLoadPromiseReject=t})}load(){return this._loadingTriggered||(this._loadingTriggered=!0,t[this._languageId].loader().then(e=>this._lazyLoadPromiseResolve(e),e=>this._lazyLoadPromiseReject(e))),this._lazyLoadPromise}};function i(n){let i=n.id;t[i]=n,e.register(n);let a=r.getOrCreate(i);e.registerTokensProviderFactory(i,{create:async()=>(await a.load()).language}),e.onLanguageEncountered(i,async()=>{let t=await a.load();e.setLanguageConfiguration(i,t.conf)})}export{i as t};
+import{h as e}from"./editor.api2-BM_YT0wu.js";import"./toggleHighContrast-CYWWoXog.js";var t={},n={},r=class e{static getOrCreate(t){return n[t]||(n[t]=new e(t)),n[t]}constructor(e){this._languageId=e,this._loadingTriggered=!1,this._lazyLoadPromise=new Promise((e,t)=>{this._lazyLoadPromiseResolve=e,this._lazyLoadPromiseReject=t})}load(){return this._loadingTriggered||(this._loadingTriggered=!0,t[this._languageId].loader().then(e=>this._lazyLoadPromiseResolve(e),e=>this._lazyLoadPromiseReject(e))),this._lazyLoadPromise}};function i(n){let i=n.id;t[i]=n,e.register(n);let a=r.getOrCreate(i);e.registerTokensProviderFactory(i,{create:async()=>(await a.load()).language}),e.onLanguageEncountered(i,async()=>{let t=await a.load();e.setLanguageConfiguration(i,t.conf)})}export{i as t};

src/www/assets/_error-BSLzv73v.js

@@ -0,0 +1 @@
+import{em as e}from"./messages-Bp0bCjzp.js";import{m as t}from"./search-provider-Bl2HDfcG.js";import{n,t as r}from"./theme-switch-B3Qb32n8.js";import{t as i}from"./general-error-BoIfl_4Z.js";import{t as a}from"./not-found-error-CHHM1I1c.js";import{t as o}from"./_error-CeoUllM-.js";import{t as s}from"./unauthorized-error-B6bKLdq-.js";import{t as c}from"./forbidden-DZPSchCU.js";import{t as l}from"./maintenance-error-CuCw7L8t.js";import{n as u,r as d,t as f}from"./header-D45l3Ai7.js";var p=e();function m(){let{error:e}=o.useParams(),m={unauthorized:s,forbidden:c,"not-found":a,"internal-server-error":i,"maintenance-error":l}[e]||a;return(0,p.jsxs)(p.Fragment,{children:[(0,p.jsxs)(f,{className:`border-b`,fixed:!0,children:[(0,p.jsx)(u,{}),(0,p.jsxs)(`div`,{className:`ms-auto flex items-center space-x-4`,children:[(0,p.jsx)(n,{}),(0,p.jsx)(r,{}),(0,p.jsx)(t,{}),(0,p.jsx)(d,{})]})]}),(0,p.jsx)(`div`,{className:`flex-1 [&>div]:h-full`,children:(0,p.jsx)(m,{})})]})}export{m as component};

src/www/assets/_error-CeoUllM-.js

@@ -0,0 +1,2 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/_error-BSLzv73v.js","assets/search-provider-Bl2HDfcG.js","assets/chunk-DECur_0Z.js","assets/dist-CRowTfGU.js","assets/dist-CKFLmh1A.js","assets/messages-Bp0bCjzp.js","assets/react-CO2uhaBc.js","assets/confirm-dialog-YmxNnOr3.js","assets/button-BgMnOYKD.js","assets/clsx-D9aGYY3V.js","assets/dist-CPQ-sRtL.js","assets/dist-_ND6L-P3.js","assets/dist-B0ikDpJU.js","assets/dist-BFnxq45V.js","assets/es2015-D8VLlhse.js","assets/dist-Clua1vrx.js","assets/dist-C97YBjnT.js","assets/dist-036CEgdV.js","assets/dist-D7AUoOWu.js","assets/dist-C6i4A_Js.js","assets/dist-BixeH3nX.js","assets/dist-DGDEBCW9.js","assets/separator-DbmFQXe4.js","assets/tooltip-Gx9CUpPD.js","assets/dist-BSXD7MjW.js","assets/dist-Bmn8KNt7.js","assets/auth-store-Csn6HPxJ.js","assets/dist-BGqHIBUe.js","assets/with-selector-DBfssCrY.js","assets/cookies-BzZOQYPw.js","assets/useRouter-DtTm7XkK.js","assets/useNavigate-7u4DX0Ho.js","assets/useStore-CupyIEEP.js","assets/command-CIv3ggHf.js","assets/createLucideIcon-Br0Bd5k2.js","assets/dialog-BJ5VA2v_.js","assets/skeleton-BQsmx80h.js","assets/wallet-Bgblr4kl.js","assets/sun-JU8p4FoE.js","assets/shield-check-MAPDL1u8.js","assets/logo-Ce__4GTc.js","assets/input-BleRUV2A.js","assets/font-provider-CtpKPVa7.js","assets/theme-provider-CyJJNAox.js","assets/theme-switch-B3Qb32n8.js","assets/dropdown-menu-8-hEBtzr.js","assets/check-CHp0nSkR.js","assets/header-D45l3Ai7.js","assets/link-BYG8nKNO.js","assets/ClientOnly-fFIveJVd.js","assets/forbidden-DZPSchCU.js","assets/general-error-BoIfl_4Z.js","assets/maintenance-error-CuCw7L8t.js","assets/not-found-error-CHHM1I1c.js","assets/unauthorized-error-B6bKLdq-.js"])))=>i.map(i=>d[i]);
+import{n as e,t}from"./lazyRouteComponent-iygd3-DM.js";import{t as n}from"./preload-helper-DoS0eHac.js";var r=e(`/_authenticated/errors/$error`)({component:t(()=>n(()=>import(`./_error-BSLzv73v.js`),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54])),`component`)});export{r as t};

src/www/assets/_error-D4dSyXw0.js

@@ -1 +0,0 @@
-import{Pp as e}from"./messages-d1hRBHLP.js";import{m as t}from"./search-provider-Zrg-SPXk.js";import{n,t as r}from"./theme-switch-DporjlJW.js";import{t as i}from"./general-error-CkWgD-Kh.js";import{t as a}from"./not-found-error-AnL_Yh5s.js";import{t as o}from"./_error-DqSF-qO2.js";import{t as s}from"./unauthorized-error-Dv-DRB5e.js";import{t as c}from"./forbidden-CHYUR1RB.js";import{t as l}from"./maintenance-error-CpldkShG.js";import{n as u,r as d,t as f}from"./header-BZlnQmen.js";var p=e();function m(){let{error:e}=o.useParams(),m={unauthorized:s,forbidden:c,"not-found":a,"internal-server-error":i,"maintenance-error":l}[e]||a;return(0,p.jsxs)(p.Fragment,{children:[(0,p.jsxs)(f,{className:`border-b`,fixed:!0,children:[(0,p.jsx)(u,{}),(0,p.jsxs)(`div`,{className:`ms-auto flex items-center space-x-4`,children:[(0,p.jsx)(n,{}),(0,p.jsx)(r,{}),(0,p.jsx)(t,{}),(0,p.jsx)(d,{})]})]}),(0,p.jsx)(`div`,{className:`flex-1 [&>div]:h-full`,children:(0,p.jsx)(m,{})})]})}export{m as component};

src/www/assets/_error-DqSF-qO2.js

@@ -1,2 +0,0 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/_error-D4dSyXw0.js","assets/search-provider-Zrg-SPXk.js","assets/chunk-DECur_0Z.js","assets/dist-CRowTfGU.js","assets/dist-CIovDv3v.js","assets/messages-d1hRBHLP.js","assets/react-CO2uhaBc.js","assets/confirm-dialog-CIBixfaW.js","assets/button-CbdgUDvS.js","assets/clsx-D9aGYY3V.js","assets/dist-BjDKUEMi.js","assets/dist-ByVfo7qC.js","assets/dist-qAA-axL4.js","assets/dist-CXfAGnWR.js","assets/es2015-Chgs9D7p.js","assets/dist-xVhEP_Vg.js","assets/dist-s_CiB-DN.js","assets/dist-BlTmpVme.js","assets/dist-D13PZ7es.js","assets/dist-DOx-EAQr.js","assets/dist-BixeH3nX.js","assets/dist-DuNl0ZwE.js","assets/separator-CE12xF6y.js","assets/tooltip-DuzUBeLr.js","assets/dist-BIXdBdVU.js","assets/dist-BGJ_1VEi.js","assets/auth-store-GibZbQPL.js","assets/dist-Bk35TVDN.js","assets/with-selector-DBfssCrY.js","assets/cookies-BzZOQYPw.js","assets/useRouter-DtTm7XkK.js","assets/useNavigate-7u4DX0Ho.js","assets/useStore-CupyIEEP.js","assets/command-DIyNKYlo.js","assets/createLucideIcon-Br0Bd5k2.js","assets/dialog-SgRLLGoQ.js","assets/skeleton-DwLAyCLM.js","assets/wallet-CkKQfl5z.js","assets/sun-BwqrnykR.js","assets/shield-check-CiWq1V4z.js","assets/logo-CGyEdT5T.js","assets/input-CusCjhBW.js","assets/font-provider-aBht_Njp.js","assets/theme-provider-BXElecjF.js","assets/theme-switch-DporjlJW.js","assets/dropdown-menu-DwTFINO1.js","assets/check-DldThLle.js","assets/header-BZlnQmen.js","assets/link-Br2JDLvw.js","assets/ClientOnly-CMPEj0pJ.js","assets/forbidden-CHYUR1RB.js","assets/general-error-CkWgD-Kh.js","assets/maintenance-error-CpldkShG.js","assets/not-found-error-AnL_Yh5s.js","assets/unauthorized-error-Dv-DRB5e.js"])))=>i.map(i=>d[i]);
-import{n as e,t}from"./lazyRouteComponent-CFOfOLgA.js";import{t as n}from"./preload-helper-vQKTmgnp.js";var r=e(`/_authenticated/errors/$error`)({component:t(()=>n(()=>import(`./_error-D4dSyXw0.js`),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54])),`component`)});export{r as t};

src/www/assets/_trade_id-BQK1SM3u.js

@@ -0,0 +1,2 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/_trade_id-Busmu9hU.js","assets/chunk-DECur_0Z.js","assets/button-BgMnOYKD.js","assets/clsx-D9aGYY3V.js","assets/messages-Bp0bCjzp.js","assets/react-CO2uhaBc.js","assets/select-C9s05In_.js","assets/dist-BSXD7MjW.js","assets/dist-CKFLmh1A.js","assets/dist-B0ikDpJU.js","assets/dist-BFnxq45V.js","assets/dist-DGDEBCW9.js","assets/dist-CRowTfGU.js","assets/dist-C6i4A_Js.js","assets/dist-C97YBjnT.js","assets/dist-_ND6L-P3.js","assets/es2015-D8VLlhse.js","assets/dist-BixeH3nX.js","assets/dist-Bmn8KNt7.js","assets/createLucideIcon-Br0Bd5k2.js","assets/check-CHp0nSkR.js","assets/chevron-down-BB5h1CsX.js","assets/auth-store-Csn6HPxJ.js","assets/dist-BGqHIBUe.js","assets/with-selector-DBfssCrY.js","assets/cookies-BzZOQYPw.js","assets/useNavigate-7u4DX0Ho.js","assets/useRouter-DtTm7XkK.js","assets/copy-to-clipboard-C1tj4a8X.js","assets/arrow-left-right-CcCrkQiR.js","assets/arrow-left-BpZwGREZ.js","assets/radio-group-DrQ9k883.js","assets/dist-036CEgdV.js","assets/dist-Clua1vrx.js","assets/dist-D7AUoOWu.js","assets/loader-circle-DpEz1fQv.js","assets/send-BNvceEpO.js","assets/triangle-alert-DB5v_9sS.js","assets/dialog-BJ5VA2v_.js","assets/dist-CPQ-sRtL.js","assets/crypto-icon-DsKMU9xz.js","assets/labels-D0HnAPk9.js","assets/input-BleRUV2A.js","assets/checkout-model-CQ3aqlob.js"])))=>i.map(i=>d[i]);
+import{n as e,t}from"./lazyRouteComponent-iygd3-DM.js";import{t as n}from"./preload-helper-DoS0eHac.js";var r=e(`/cashier/$trade_id/`)({component:t(()=>n(()=>import(`./_trade_id-Busmu9hU.js`),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43])),`component`)});export{r as t};

src/www/assets/_trade_id-DQBHJdGw.js

@@ -1,2 +0,0 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/_trade_id-Ck9STVZb.js","assets/chunk-DECur_0Z.js","assets/button-CbdgUDvS.js","assets/clsx-D9aGYY3V.js","assets/messages-d1hRBHLP.js","assets/react-CO2uhaBc.js","assets/select-Cv_sRi68.js","assets/dist-BIXdBdVU.js","assets/dist-CIovDv3v.js","assets/dist-qAA-axL4.js","assets/dist-CXfAGnWR.js","assets/dist-DuNl0ZwE.js","assets/dist-CRowTfGU.js","assets/dist-DOx-EAQr.js","assets/dist-s_CiB-DN.js","assets/dist-ByVfo7qC.js","assets/es2015-Chgs9D7p.js","assets/dist-BixeH3nX.js","assets/dist-BGJ_1VEi.js","assets/createLucideIcon-Br0Bd5k2.js","assets/check-DldThLle.js","assets/chevron-down-BPPKEraq.js","assets/auth-store-GibZbQPL.js","assets/dist-Bk35TVDN.js","assets/with-selector-DBfssCrY.js","assets/cookies-BzZOQYPw.js","assets/useNavigate-7u4DX0Ho.js","assets/useRouter-DtTm7XkK.js","assets/copy-to-clipboard--eZunBzP.js","assets/arrow-left-Ck1MERx0.js","assets/radio-group-CX51BC9z.js","assets/dist-BlTmpVme.js","assets/dist-xVhEP_Vg.js","assets/dist-D13PZ7es.js","assets/loader-circle-DRj7MiMc.js","assets/send-g-CrrC4k.js","assets/triangle-alert-BEkslGAT.js","assets/dialog-SgRLLGoQ.js","assets/dist-BjDKUEMi.js","assets/crypto-icon-BwB-F_ID.js","assets/labels-CfnKbsNx.js","assets/input-CusCjhBW.js","assets/checkout-model-CY0q1fms.js"])))=>i.map(i=>d[i]);
-import{n as e,t}from"./lazyRouteComponent-CFOfOLgA.js";import{t as n}from"./preload-helper-vQKTmgnp.js";var r=e(`/cashier/$trade_id/`)({component:t(()=>n(()=>import(`./_trade_id-Ck9STVZb.js`),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42])),`component`)});export{r as t};

src/www/assets/appearance-CslRyYyk.js

@@ -1 +1 @@
-import{Cp as e,Pp as t,Sp as n,_n as r,bn as i,gn as a,hn as o,mn as s,vn as c,yn as l}from"./messages-d1hRBHLP.js";import{i as u,n as d,t as f}from"./button-CbdgUDvS.js";import{n as p,r as m}from"./font-provider-aBht_Njp.js";import{n as h}from"./theme-provider-BXElecjF.js";import{t as g}from"./chevron-down-BPPKEraq.js";import{n as _,t as v}from"./radio-group-CX51BC9z.js";import{r as y,s as b}from"./zod-CQemhjci.js";import{a as x,c as S,i as C,l as w,n as T,o as E,r as D,s as O,t as k}from"./form-Db7d571a.js";import{t as A}from"./page-header-DkeFH2Rh.js";import{t as j}from"./show-submitted-data-CfmGDLbU.js";var M=t(),N=b({theme:y([`light`,`dark`]),font:y(m)});function P(){let{font:t,setFont:i}=p(),{theme:l,setTheme:y}=h(),b={theme:l,font:t},A=w({resolver:S(N),defaultValues:b});function P(e){e.font!==t&&i(e.font),e.theme!==l&&y(e.theme),j(e)}return(0,M.jsx)(k,{...A,children:(0,M.jsxs)(`form`,{className:`space-y-8`,onSubmit:A.handleSubmit(P),children:[(0,M.jsx)(C,{control:A.control,name:`font`,render:({field:e})=>(0,M.jsxs)(x,{children:[(0,M.jsx)(E,{children:c()}),(0,M.jsxs)(`div`,{className:`relative w-max`,children:[(0,M.jsx)(T,{children:(0,M.jsx)(`select`,{className:u(d({variant:`outline`}),`w-50 appearance-none font-normal capitalize`,`dark:bg-background dark:hover:bg-background`),...e,children:m.map(e=>(0,M.jsx)(`option`,{value:e,children:e},e))})}),(0,M.jsx)(g,{className:`absolute inset-e-3 top-2.5 h-4 w-4 opacity-50`})]}),(0,M.jsx)(D,{className:`font-manrope`,children:r()}),(0,M.jsx)(O,{})]})}),(0,M.jsx)(C,{control:A.control,name:`theme`,render:({field:t})=>(0,M.jsxs)(x,{children:[(0,M.jsx)(E,{children:a()}),(0,M.jsx)(D,{children:o()}),(0,M.jsx)(O,{}),(0,M.jsxs)(v,{className:`grid max-w-md grid-cols-2 gap-8 pt-2`,defaultValue:t.value,onValueChange:t.onChange,children:[(0,M.jsx)(x,{children:(0,M.jsxs)(E,{className:`[&:has([data-state=checked])>div]:border-primary`,children:[(0,M.jsx)(T,{children:(0,M.jsx)(_,{className:`sr-only`,value:`light`})}),(0,M.jsx)(`div`,{className:`items-center rounded-md border-2 border-muted p-1 hover:border-accent`,children:(0,M.jsxs)(`div`,{className:`space-y-2 rounded-sm bg-[#ecedef] p-2`,children:[(0,M.jsxs)(`div`,{className:`space-y-2 rounded-md bg-white p-2 shadow-xs`,children:[(0,M.jsx)(`div`,{className:`h-2 w-20 rounded-lg bg-[#ecedef]`}),(0,M.jsx)(`div`,{className:`h-2 w-25 rounded-lg bg-[#ecedef]`})]}),(0,M.jsxs)(`div`,{className:`flex items-center space-x-2 rounded-md bg-white p-2 shadow-xs`,children:[(0,M.jsx)(`div`,{className:`h-4 w-4 rounded-full bg-[#ecedef]`}),(0,M.jsx)(`div`,{className:`h-2 w-25 rounded-lg bg-[#ecedef]`})]}),(0,M.jsxs)(`div`,{className:`flex items-center space-x-2 rounded-md bg-white p-2 shadow-xs`,children:[(0,M.jsx)(`div`,{className:`h-4 w-4 rounded-full bg-[#ecedef]`}),(0,M.jsx)(`div`,{className:`h-2 w-25 rounded-lg bg-[#ecedef]`})]})]})}),(0,M.jsx)(`span`,{className:`block w-full p-2 text-center font-normal`,children:e()})]})}),(0,M.jsx)(x,{children:(0,M.jsxs)(E,{className:`[&:has([data-state=checked])>div]:border-primary`,children:[(0,M.jsx)(T,{children:(0,M.jsx)(_,{className:`sr-only`,value:`dark`})}),(0,M.jsx)(`div`,{className:`items-center rounded-md border-2 border-muted bg-popover p-1 hover:bg-accent hover:text-accent-foreground`,children:(0,M.jsxs)(`div`,{className:`space-y-2 rounded-sm bg-slate-950 p-2`,children:[(0,M.jsxs)(`div`,{className:`space-y-2 rounded-md bg-slate-800 p-2 shadow-xs`,children:[(0,M.jsx)(`div`,{className:`h-2 w-20 rounded-lg bg-slate-400`}),(0,M.jsx)(`div`,{className:`h-2 w-25 rounded-lg bg-slate-400`})]}),(0,M.jsxs)(`div`,{className:`flex items-center space-x-2 rounded-md bg-slate-800 p-2 shadow-xs`,children:[(0,M.jsx)(`div`,{className:`h-4 w-4 rounded-full bg-slate-400`}),(0,M.jsx)(`div`,{className:`h-2 w-25 rounded-lg bg-slate-400`})]}),(0,M.jsxs)(`div`,{className:`flex items-center space-x-2 rounded-md bg-slate-800 p-2 shadow-xs`,children:[(0,M.jsx)(`div`,{className:`h-4 w-4 rounded-full bg-slate-400`}),(0,M.jsx)(`div`,{className:`h-2 w-25 rounded-lg bg-slate-400`})]})]})}),(0,M.jsx)(`span`,{className:`block w-full p-2 text-center font-normal`,children:n()})]})})]})]})}),(0,M.jsx)(f,{type:`submit`,children:s()})]})})}function F(){return(0,M.jsx)(A,{description:l(),title:i(),variant:`section`,children:(0,M.jsx)(P,{})})}var I=F;export{I as component};
+import{Cn as e,Hp as t,Sn as n,Up as r,_n as i,bn as a,em as o,vn as s,xn as c,yn as l}from"./messages-Bp0bCjzp.js";import{i as u,n as d,t as f}from"./button-BgMnOYKD.js";import{n as p,r as m}from"./font-provider-CtpKPVa7.js";import{n as h}from"./theme-provider-CyJJNAox.js";import{t as g}from"./chevron-down-BB5h1CsX.js";import{n as _,t as v}from"./radio-group-DrQ9k883.js";import{r as y,s as b}from"./zod-rwFXxHlg.js";import{a as x,c as S,i as C,l as w,n as T,o as E,r as D,s as O,t as k}from"./form-BhKmyN6D.js";import{t as A}from"./page-header-CDwG3nxs.js";import{t as j}from"./show-submitted-data-C8ocsjDF.js";var M=o(),N=b({theme:y([`light`,`dark`]),font:y(m)});function P(){let{font:e,setFont:n}=p(),{theme:o,setTheme:y}=h(),b={theme:o,font:e},A=w({resolver:S(N),defaultValues:b});function P(t){t.font!==e&&n(t.font),t.theme!==o&&y(t.theme),j(t)}return(0,M.jsx)(k,{...A,children:(0,M.jsxs)(`form`,{className:`space-y-8`,onSubmit:A.handleSubmit(P),children:[(0,M.jsx)(C,{control:A.control,name:`font`,render:({field:e})=>(0,M.jsxs)(x,{children:[(0,M.jsx)(E,{children:c()}),(0,M.jsxs)(`div`,{className:`relative w-max`,children:[(0,M.jsx)(T,{children:(0,M.jsx)(`select`,{className:u(d({variant:`outline`}),`w-50 appearance-none font-normal capitalize`,`dark:bg-background dark:hover:bg-background`),...e,children:m.map(e=>(0,M.jsx)(`option`,{value:e,children:e},e))})}),(0,M.jsx)(g,{className:`absolute inset-e-3 top-2.5 h-4 w-4 opacity-50`})]}),(0,M.jsx)(D,{className:`font-manrope`,children:a()}),(0,M.jsx)(O,{})]})}),(0,M.jsx)(C,{control:A.control,name:`theme`,render:({field:e})=>(0,M.jsxs)(x,{children:[(0,M.jsx)(E,{children:l()}),(0,M.jsx)(D,{children:s()}),(0,M.jsx)(O,{}),(0,M.jsxs)(v,{className:`grid max-w-md grid-cols-2 gap-8 pt-2`,defaultValue:e.value,onValueChange:e.onChange,children:[(0,M.jsx)(x,{children:(0,M.jsxs)(E,{className:`[&:has([data-state=checked])>div]:border-primary`,children:[(0,M.jsx)(T,{children:(0,M.jsx)(_,{className:`sr-only`,value:`light`})}),(0,M.jsx)(`div`,{className:`items-center rounded-md border-2 border-muted p-1 hover:border-accent`,children:(0,M.jsxs)(`div`,{className:`space-y-2 rounded-sm bg-[#ecedef] p-2`,children:[(0,M.jsxs)(`div`,{className:`space-y-2 rounded-md bg-white p-2 shadow-xs`,children:[(0,M.jsx)(`div`,{className:`h-2 w-20 rounded-lg bg-[#ecedef]`}),(0,M.jsx)(`div`,{className:`h-2 w-25 rounded-lg bg-[#ecedef]`})]}),(0,M.jsxs)(`div`,{className:`flex items-center space-x-2 rounded-md bg-white p-2 shadow-xs`,children:[(0,M.jsx)(`div`,{className:`h-4 w-4 rounded-full bg-[#ecedef]`}),(0,M.jsx)(`div`,{className:`h-2 w-25 rounded-lg bg-[#ecedef]`})]}),(0,M.jsxs)(`div`,{className:`flex items-center space-x-2 rounded-md bg-white p-2 shadow-xs`,children:[(0,M.jsx)(`div`,{className:`h-4 w-4 rounded-full bg-[#ecedef]`}),(0,M.jsx)(`div`,{className:`h-2 w-25 rounded-lg bg-[#ecedef]`})]})]})}),(0,M.jsx)(`span`,{className:`block w-full p-2 text-center font-normal`,children:r()})]})}),(0,M.jsx)(x,{children:(0,M.jsxs)(E,{className:`[&:has([data-state=checked])>div]:border-primary`,children:[(0,M.jsx)(T,{children:(0,M.jsx)(_,{className:`sr-only`,value:`dark`})}),(0,M.jsx)(`div`,{className:`items-center rounded-md border-2 border-muted bg-popover p-1 hover:bg-accent hover:text-accent-foreground`,children:(0,M.jsxs)(`div`,{className:`space-y-2 rounded-sm bg-slate-950 p-2`,children:[(0,M.jsxs)(`div`,{className:`space-y-2 rounded-md bg-slate-800 p-2 shadow-xs`,children:[(0,M.jsx)(`div`,{className:`h-2 w-20 rounded-lg bg-slate-400`}),(0,M.jsx)(`div`,{className:`h-2 w-25 rounded-lg bg-slate-400`})]}),(0,M.jsxs)(`div`,{className:`flex items-center space-x-2 rounded-md bg-slate-800 p-2 shadow-xs`,children:[(0,M.jsx)(`div`,{className:`h-4 w-4 rounded-full bg-slate-400`}),(0,M.jsx)(`div`,{className:`h-2 w-25 rounded-lg bg-slate-400`})]}),(0,M.jsxs)(`div`,{className:`flex items-center space-x-2 rounded-md bg-slate-800 p-2 shadow-xs`,children:[(0,M.jsx)(`div`,{className:`h-4 w-4 rounded-full bg-slate-400`}),(0,M.jsx)(`div`,{className:`h-2 w-25 rounded-lg bg-slate-400`})]})]})}),(0,M.jsx)(`span`,{className:`block w-full p-2 text-center font-normal`,children:t()})]})})]})]})}),(0,M.jsx)(f,{type:`submit`,children:i()})]})})}function F(){return(0,M.jsx)(A,{description:n(),title:e(),variant:`section`,children:(0,M.jsx)(P,{})})}var I=F;export{I as component};