@xyo-network/chain-bridge 1.20.8 → 1.20.9

package/dist/node/server/routes/bridge/routeDefinitions/getRouteDefinitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getRouteDefinitions.d.ts","sourceRoot":"","sources":["../../../../../../src/server/routes/bridge/routeDefinitions/getRouteDefinitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAM5D,eAAO,MAAM,mBAAmB,GAAI,QAAQ,YAAY,EAAE,SAAS,gBAAgB,KAAG,eAAe,EAQpG,CAAA"}
+{"version":3,"file":"getRouteDefinitions.d.ts","sourceRoot":"","sources":["../../../../../../src/server/routes/bridge/routeDefinitions/getRouteDefinitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAM5D,eAAO,MAAM,mBAAmB,GAAI,QAAQ,YAAY,EAAE,SAAS,gBAAgB,KAAG,eAAe,EASpG,CAAA"}

package/dist/node/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bridgeToRemoteEstimate.d.ts","sourceRoot":"","sources":["../../../../../../../src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAGtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAEpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAI5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,6BAA6B;;;;iBAIxC,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEtF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAI5C,CAAA;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAE9F,eAAO,MAAM,+BAA+B,GAAI,QAAQ,YAAY,EAAE,SAAS,gBAAgB,KAAG,eA6BjG,CAAA"}
+{"version":3,"file":"bridgeToRemoteEstimate.d.ts","sourceRoot":"","sources":["../../../../../../../src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAKtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAEpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAI5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,6BAA6B;;;;iBAIxC,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEtF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAI5C,CAAA;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAE9F,eAAO,MAAM,+BAA+B,GAAI,QAAQ,YAAY,EAAE,SAAS,gBAAgB,KAAG,eAoCjG,CAAA"}

package/dist/node/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteMaxEstimate.d.ts

@@ -0,0 +1,77 @@
+import type { RouteDefinition } from '@xylabs/express';
+import type { BridgeConfig } from '@xyo-network/chain-orchestration';
+import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk';
+import { z } from 'zod';
+export declare const BridgeToRemoteMaxEstimateBodyZod: z.ZodObject<{
+    srcAmount: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+    srcAddress: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+    destAddress: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+}, z.core.$strip>;
+export type BridgeToRemoteMaxEstimateBody = z.infer<typeof BridgeToRemoteMaxEstimateBodyZod>;
+export declare const BridgeToRemoteMaxEstimateResponseZod: z.ZodTuple<[z.ZodObject<{
+    schema: z.ZodLiteral<"network.xyo.boundwitness" & {
+        readonly __schema: true;
+    }>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>>;
+    payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>>;
+    payload_schemas: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/sdk-js").BrandedSchema<string>, string>>>;
+    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>>;
+    $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHash, string>>>;
+    $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodNull]>>;
+    nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-sdk").XL1BlockNumber, number>>;
+    exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-sdk").XL1BlockNumber, number>>;
+    fees: z.ZodObject<{
+        base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+        gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+        gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+        priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+    }, z.core.$strip>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>;
+    script: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    schema: z.ZodLiteral<"network.xyo.chain.bridge.intent" & {
+        readonly __schema: true;
+    }>;
+    src: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+    srcAddress: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+    srcAmount: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+    srcToken: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+    dest: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+    destAddress: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+    destAmount: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+    destToken: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+    nonce: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"network.xyo.transfer" & {
+        readonly __schema: true;
+    }>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    epoch: z.ZodNumber;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>;
+    transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
+}, z.core.$strip>], null>;
+export type BridgeToRemoteMaxEstimateResponse = z.infer<typeof BridgeToRemoteMaxEstimateResponseZod>;
+export declare const makeBridgeToRemoteMaxEstimateRoute: (config: BridgeConfig, gateway: XyoGatewayRunner) => RouteDefinition;
+//# sourceMappingURL=bridgeToRemoteMaxEstimate.d.ts.map

package/dist/node/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteMaxEstimate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridgeToRemoteMaxEstimate.d.ts","sourceRoot":"","sources":["../../../../../../../src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteMaxEstimate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAKtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAEpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAI5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,gCAAgC;;;;iBAI3C,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAE5F,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAI/C,CAAA;AAEF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AAEpG,eAAO,MAAM,kCAAkC,GAAI,QAAQ,YAAY,EAAE,SAAS,gBAAgB,KAAG,eA+BpG,CAAA"}

package/dist/node/server/routes/bridge/routeDefinitions/routes/index.d.ts

@@ -2,5 +2,6 @@ export * from './bridgeConfig.ts';
 export * from './bridgeFromRemoteStatus.ts';
 export * from './bridgeToRemote.ts';
 export * from './bridgeToRemoteEstimate.ts';
+export * from './bridgeToRemoteMaxEstimate.ts';
 export * from './bridgeToRemoteStatus.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/node/server/routes/bridge/routeDefinitions/routes/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/server/routes/bridge/routeDefinitions/routes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,qBAAqB,CAAA;AACnC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,2BAA2B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/server/routes/bridge/routeDefinitions/routes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,qBAAqB,CAAA;AACnC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,2BAA2B,CAAA"}

package/dist/node/util/calculateMaxBridgeAmount.d.ts

@@ -0,0 +1,11 @@
+import type { Hex } from '@xylabs/sdk-js';
+import type { FeeStructure } from './calculateBridgeFees.ts';
+/**
+ * Given a user's total available balance, calculates the maximum amount they can bridge
+ * after accounting for the fixed and variable bridge fees.
+ *
+ * Solving for M where: M + feeFixed + (M * basisPoints / 10_000) = balance
+ * => M = (balance - feeFixed) * 10_000 / (10_000 + basisPoints)
+ */
+export declare const calculateMaxBridgeAmount: (balance: Hex, feeStructure: FeeStructure) => Hex;
+//# sourceMappingURL=calculateMaxBridgeAmount.d.ts.map

package/dist/node/util/calculateMaxBridgeAmount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateMaxBridgeAmount.d.ts","sourceRoot":"","sources":["../../../src/util/calculateMaxBridgeAmount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AAGzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS,GAAG,EAAE,cAAc,YAAY,KAAG,GASnF,CAAA"}

package/dist/node/util/index.d.ts

@@ -1,6 +1,7 @@
 export * from './BridgeFees.ts';
 export * from './bridgeFeesAsBigInt.ts';
 export * from './calculateBridgeFees.ts';
+export * from './calculateMaxBridgeAmount.ts';
 export * from './createBridgeTransfer.ts';
 export * from './generateBridgeEstimate.ts';
 export * from './getConfigFromEnv.ts';

package/dist/node/util/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/util/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,yBAAyB,CAAA;AACvC,cAAc,0BAA0B,CAAA;AACxC,cAAc,2BAA2B,CAAA;AACzC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,uBAAuB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/util/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,yBAAyB,CAAA;AACvC,cAAc,0BAA0B,CAAA;AACxC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,2BAA2B,CAAA;AACzC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,uBAAuB,CAAA"}

package/dist/node/validation/validateBridgeEstimateExact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateBridgeEstimateExact.d.ts","sourceRoot":"","sources":["../../../src/validation/validateBridgeEstimateExact.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAEpE,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAIlE;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,GACtC,QAAQ,YAAY,EACpB,UAAU,QAAQ,EAClB,QAAQ,YAAY,KACnB,OAAO,CAAC,OAAO,CAcjB,CAAA"}
+{"version":3,"file":"validateBridgeEstimateExact.d.ts","sourceRoot":"","sources":["../../../src/validation/validateBridgeEstimateExact.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAEpE,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAKlE;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,GACtC,QAAQ,YAAY,EACpB,UAAU,QAAQ,EAClB,QAAQ,YAAY,KACnB,OAAO,CAAC,OAAO,CAkBjB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/chain-bridge",
-  "version": "1.20.8",
+  "version": "1.20.9",
   "description": "XYO Layer One Bridge",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -49,51 +49,51 @@
     "types": "tsc --noEmit -p tsconfig.test.json"
   },
   "dependencies": {
-    "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/instrumentation": "~0.213.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/instrumentation": "~0.214.0",
     "@opentelemetry/instrumentation-express": "~0.61.0",
-    "@opentelemetry/instrumentation-http": "~0.213.0",
-    "@xylabs/express": "~5.0.86",
-    "@xylabs/mongo": "~5.0.86",
-    "@xylabs/sdk-js": "~5.0.86",
+    "@opentelemetry/instrumentation-http": "~0.214.0",
+    "@xylabs/express": "~5.0.87",
+    "@xylabs/mongo": "~5.0.87",
+    "@xylabs/sdk-js": "~5.0.87",
     "@xyo-network/boundwitness-validator": "~5.3.16",
-    "@xyo-network/chain-orchestration": "~1.20.8",
-    "@xyo-network/chain-protocol": "~1.20.8",
-    "@xyo-network/chain-services": "~1.20.8",
+    "@xyo-network/chain-orchestration": "~1.20.9",
+    "@xyo-network/chain-protocol": "~1.20.9",
+    "@xyo-network/chain-services": "~1.20.9",
     "@xyo-network/sdk-js": "~5.3.16",
     "@xyo-network/typechain": "~4.1.2",
     "@xyo-network/wallet-model": "~5.3.16",
-    "@xyo-network/xl1-sdk": "~1.25.33",
+    "@xyo-network/xl1-sdk": "~1.26.4",
     "async-mutex": "~0.5.0",
-    "bullmq": "~5.71.0",
+    "bullmq": "~5.71.1",
     "bullmq-otel": "~1.3.0",
     "ethers": "^6.16.0",
     "express": "~5.2.1",
-    "ioredis": "5.9.3",
-    "mongodb": "^7.1.0",
+    "ioredis": "5.10.1",
+    "mongodb": "~7.1.1",
     "uuid": "~13.0.0",
     "yargs-parser": "~22.0.0"
   },
   "devDependencies": {
-    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/api": "^1.9.1",
     "@types/node": "~25.5.0",
     "@types/yargs-parser": "~21.0.3",
-    "@xylabs/mongo": "~5.0.86",
-    "@xylabs/sdk-js": "~5.0.86",
-    "@xylabs/ts-scripts-yarn3": "~7.4.25",
-    "@xylabs/tsconfig": "~7.4.25",
-    "@xylabs/vitest-extended": "~5.0.86",
-    "@xyo-network/chain-protocol": "~1.20.8",
-    "@xyo-network/chain-services": "~1.20.8",
+    "@xylabs/mongo": "~5.0.87",
+    "@xylabs/sdk-js": "~5.0.87",
+    "@xylabs/ts-scripts-yarn3": "~7.4.28",
+    "@xylabs/tsconfig": "~7.4.28",
+    "@xylabs/vitest-extended": "~5.0.87",
+    "@xyo-network/chain-protocol": "~1.20.9",
+    "@xyo-network/chain-services": "~1.20.9",
     "@xyo-network/chain-test-helpers": "workspace:packages/test-helpers",
     "@xyo-network/sdk-js": "~5.3.16",
-    "@xyo-network/xl1-sdk": "~1.25.33",
+    "@xyo-network/xl1-sdk": "~1.26.4",
     "async-mutex": "~0.5.0",
     "axios": "~1.13.6",
     "dotenv": "~17.3.1",
     "ethers": "^6.16.0",
     "http-status-codes": "~2.3.0",
-    "mongodb": "~7.1.0",
+    "mongodb": "~7.1.1",
     "nodemon": "~3.1.14",
     "tslib": "~2.8.1",
     "typescript": "~5.9.3",

package/src/server/routes/bridge/routeDefinitions/getRouteDefinitions.ts

@@ -3,13 +3,14 @@ import type { BridgeConfig } from '@xyo-network/chain-orchestration'
 import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
 
 import {
-  makeBridgeConfigRoute, makeBridgeFromRemoteStatusRoute, makeBridgeToRemoteEstimateRoute, makeBridgeToRemoteRoute, makeBridgeToRemoteStatusRoute,
+  makeBridgeConfigRoute, makeBridgeFromRemoteStatusRoute, makeBridgeToRemoteEstimateRoute, makeBridgeToRemoteMaxEstimateRoute, makeBridgeToRemoteRoute, makeBridgeToRemoteStatusRoute,
 } from './routes/index.ts'
 
 export const getRouteDefinitions = (config: BridgeConfig, gateway: XyoGatewayRunner): RouteDefinition[] => {
   return [
     makeBridgeConfigRoute(config),
     makeBridgeToRemoteEstimateRoute(config, gateway),
+    makeBridgeToRemoteMaxEstimateRoute(config, gateway),
     makeBridgeToRemoteRoute(config),
     makeBridgeToRemoteStatusRoute(config),
     makeBridgeFromRemoteStatusRoute(config),

package/src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts

@@ -1,6 +1,8 @@
 import type { RouteDefinition } from '@xylabs/express'
 import { requestHandlerValidator } from '@xylabs/express'
-import { assertEx, toAddress } from '@xylabs/sdk-js'
+import {
+  assertEx, hexToBigInt, toAddress,
+} from '@xylabs/sdk-js'
 import type { BridgeConfig } from '@xyo-network/chain-orchestration'
 import { PayloadZodStrictOfSchema } from '@xyo-network/sdk-js'
 import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
@@ -9,7 +11,7 @@ import {
 } from '@xyo-network/xl1-sdk'
 import { z } from 'zod'
 
-import { getXl1ChainId } from '../../../../../config/index.ts'
+import { getBridgeSettings, getXl1ChainId } from '../../../../../config/index.ts'
 import { generateBridgeEstimate } from '../../../../../util/index.ts'
 import { getRemoteChainIdZod } from '../pathParams/index.ts'
 
@@ -41,6 +43,13 @@ export const makeBridgeToRemoteEstimateRoute = (config: BridgeConfig, gateway: X
       const {
         srcAddress, srcAmount, destAddress,
       } = req.body
+
+      const { maxBridgeAmount } = await getBridgeSettings(config)
+      if (hexToBigInt(srcAmount) > hexToBigInt(maxBridgeAmount)) {
+        res.status(400).send()
+        return
+      }
+
       const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config)
       const sender = toAddress(srcAddress)
 

package/src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteMaxEstimate.ts

@@ -0,0 +1,64 @@
+import type { RouteDefinition } from '@xylabs/express'
+import { requestHandlerValidator } from '@xylabs/express'
+import {
+  assertEx, hexToBigInt, toAddress, toHex,
+} from '@xylabs/sdk-js'
+import type { BridgeConfig } from '@xyo-network/chain-orchestration'
+import { PayloadZodStrictOfSchema } from '@xyo-network/sdk-js'
+import type { XyoGatewayRunner } from '@xyo-network/xl1-sdk'
+import {
+  BridgeIntentFieldsZod, BridgeIntentSchema, buildUnsignedTransaction, toXL1BlockNumber, TransactionBoundWitnessZod, TransferZod,
+} from '@xyo-network/xl1-sdk'
+import { z } from 'zod'
+
+import { getBridgeSettings } from '../../../../../config/index.ts'
+import { calculateMaxBridgeAmount, generateBridgeEstimate } from '../../../../../util/index.ts'
+import { getRemoteChainIdZod } from '../pathParams/index.ts'
+
+export const BridgeToRemoteMaxEstimateBodyZod = BridgeIntentFieldsZod.pick({
+  destAddress: true,
+  srcAddress: true,
+  srcAmount: true,
+})
+export type BridgeToRemoteMaxEstimateBody = z.infer<typeof BridgeToRemoteMaxEstimateBodyZod>
+
+export const BridgeToRemoteMaxEstimateResponseZod = z.tuple([
+  TransactionBoundWitnessZod,
+  PayloadZodStrictOfSchema(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
+  TransferZod,
+])
+
+export type BridgeToRemoteMaxEstimateResponse = z.infer<typeof BridgeToRemoteMaxEstimateResponseZod>
+
+export const makeBridgeToRemoteMaxEstimateRoute = (config: BridgeConfig, gateway: XyoGatewayRunner): RouteDefinition => {
+  const params = z.object({ chainId: getRemoteChainIdZod(config) })
+  const validateRequest = requestHandlerValidator({
+    params, body: BridgeToRemoteMaxEstimateBodyZod, response: BridgeToRemoteMaxEstimateResponseZod,
+  })
+  return {
+    method: 'post',
+    path: '/bridge/chains/:chainId/bridgeToRemote/maxEstimate',
+    handlers: validateRequest(async (req, res) => {
+      const {
+        feeFixed, feeRateBasisPoints, maxBridgeAmount: configMax, xl1ChainId,
+      } = await getBridgeSettings(config)
+      const {
+        srcAddress, srcAmount: balance, destAddress,
+      } = req.body
+
+      const balanceMax = calculateMaxBridgeAmount(balance, { feeFixed, feeRateBasisPoints })
+      const maxBridgeAmount = toHex(hexToBigInt(balanceMax) < hexToBigInt(configMax) ? balanceMax : configMax)
+
+      const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, maxBridgeAmount, destAddress, config)
+      const sender = toAddress(srcAddress)
+
+      const viewer = assertEx(gateway.connection.viewer, () => new Error('Viewer not available on gateway connection'))
+      const currentBlockNumber = await viewer.currentBlockNumber()
+      const nbf = toXL1BlockNumber(currentBlockNumber, true)
+      const exp = toXL1BlockNumber(currentBlockNumber + 1000, true)
+      const [txBw] = await buildUnsignedTransaction(xl1ChainId, [transfer], [bridgeIntent], nbf, exp, sender)
+
+      res.json([txBw, bridgeIntent, transfer])
+    }),
+  }
+}

package/src/server/routes/bridge/routeDefinitions/routes/index.ts

@@ -2,4 +2,5 @@ export * from './bridgeConfig.ts'
 export * from './bridgeFromRemoteStatus.ts'
 export * from './bridgeToRemote.ts'
 export * from './bridgeToRemoteEstimate.ts'
+export * from './bridgeToRemoteMaxEstimate.ts'
 export * from './bridgeToRemoteStatus.ts'

package/src/util/calculateMaxBridgeAmount.ts

@@ -0,0 +1,22 @@
+import type { Hex } from '@xylabs/sdk-js'
+import { hexToBigInt, toHex } from '@xylabs/sdk-js'
+
+import type { FeeStructure } from './calculateBridgeFees.ts'
+
+/**
+ * Given a user's total available balance, calculates the maximum amount they can bridge
+ * after accounting for the fixed and variable bridge fees.
+ *
+ * Solving for M where: M + feeFixed + (M * basisPoints / 10_000) = balance
+ * => M = (balance - feeFixed) * 10_000 / (10_000 + basisPoints)
+ */
+export const calculateMaxBridgeAmount = (balance: Hex, feeStructure: FeeStructure): Hex => {
+  const { feeFixed, feeRateBasisPoints } = feeStructure
+  const balanceBigInt = hexToBigInt(balance)
+  const feeFixedBigInt = hexToBigInt(feeFixed)
+
+  if (balanceBigInt <= feeFixedBigInt) return toHex(0n)
+
+  const maxAmount = ((balanceBigInt - feeFixedBigInt) * 10_000n) / (10_000n + BigInt(feeRateBasisPoints))
+  return toHex(maxAmount)
+}

package/src/util/index.ts

@@ -1,6 +1,7 @@
 export * from './BridgeFees.ts'
 export * from './bridgeFeesAsBigInt.ts'
 export * from './calculateBridgeFees.ts'
+export * from './calculateMaxBridgeAmount.ts'
 export * from './createBridgeTransfer.ts'
 export * from './generateBridgeEstimate.ts'
 export * from './getConfigFromEnv.ts'

package/src/validation/validateBridgeEstimateExact.ts

@@ -1,8 +1,9 @@
-import { isUndefined } from '@xylabs/sdk-js'
+import { hexToBigInt, isUndefined } from '@xylabs/sdk-js'
 import type { BridgeConfig } from '@xyo-network/chain-orchestration'
 import { PayloadBuilder } from '@xyo-network/sdk-js'
 import type { BridgeIntent, Transfer } from '@xyo-network/xl1-sdk'
 
+import { getMaxBridgeAmount } from '../config/index.ts'
 import { generateBridgeEstimate } from '../util/index.ts'
 
 /**
@@ -21,6 +22,10 @@ export const validateBridgeEstimateExact = async (
   const {
     srcAddress, srcAmount, destAddress,
   } = intent
+
+  // Reject if the requested amount exceeds the configured maximum
+  if (hexToBigInt(srcAmount) > hexToBigInt(getMaxBridgeAmount(config))) return false
+
   const [calculatedIntent, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config)
   if (isUndefined(calculatedIntent) || isUndefined(calculatedTransfer)) return false
   const { nonce: expectedIntentNonce, ...expectedIntentStatic } = calculatedIntent