tapimo 0.5.3 → 0.7.0

package/dist/apps/data/routes/funding.d.ts

@@ -23,6 +23,7 @@ export declare namespace schema {
     /** Source or destination token reference. */
     const Token: z.ZodMiniObject<{
         address: z.ZodMiniString<string>;
+        currency: z.ZodMiniString<string>;
         decimals: z.ZodMiniNumber<number>;
         metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
         name: z.ZodMiniString<string>;
@@ -31,9 +32,11 @@ export declare namespace schema {
         tokenKey: z.ZodMiniString<string>;
         verified: z.ZodMiniBoolean<boolean>;
     }, z.core.$strip>;
-    /** Source amount echoed by a funding quote response. */
+    /** Self-contained source or destination amount in a funding quote. */
     const TokenAmount: z.ZodMiniObject<{
-        amount: z.ZodMiniString<string>;
+        baseUnits: z.ZodMiniString<string>;
+        currency: z.ZodMiniString<string>;
+        decimals: z.ZodMiniNumber<number>;
         formatted: z.ZodMiniString<string>;
     }, z.core.$strip>;
     /** Provider summary embedded in a funding quote. */
@@ -43,6 +46,7 @@ export declare namespace schema {
             relay: "relay";
             rhino: "rhino";
             squid: "squid";
+            symbiosis: "symbiosis";
         }>;
         kind: z.ZodMiniString<string>;
         name: z.ZodMiniString<string>;
@@ -58,17 +62,25 @@ export declare namespace schema {
             thin: "thin";
         }>;
     }, z.core.$strip>;
-    /** Provider-derived output, limits, and freshness data. */
+    /** Provider quote freshness data. */
     const QuoteDetails: z.ZodMiniObject<{
         expiresAt: z.ZodMiniOptional<z.ZodMiniISODateTime>;
-        inputAmount: z.ZodMiniString<string>;
-        minimumOutputAmount: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        outputAmount: z.ZodMiniString<string>;
-        outputAmountFormatted: z.ZodMiniString<string>;
         sampledAt: z.ZodMiniISODateTime;
     }, z.core.$strip>;
     /** Successful live funding quote. */
     const FundingQuote: z.ZodMiniObject<{
+        destinationAmount: z.ZodMiniObject<{
+            baseUnits: z.ZodMiniString<string>;
+            currency: z.ZodMiniString<string>;
+            decimals: z.ZodMiniNumber<number>;
+            formatted: z.ZodMiniString<string>;
+        }, z.core.$strip>;
+        destinationAmountMin: z.ZodMiniOptional<z.ZodMiniObject<{
+            baseUnits: z.ZodMiniString<string>;
+            currency: z.ZodMiniString<string>;
+            decimals: z.ZodMiniNumber<number>;
+            formatted: z.ZodMiniString<string>;
+        }, z.core.$strip>>;
         destinationChain: z.ZodMiniObject<{
             addressFormat: z.ZodMiniEnum<{
                 base58: "base58";
@@ -86,6 +98,7 @@ export declare namespace schema {
         }, z.core.$strip>;
         destinationToken: z.ZodMiniObject<{
             address: z.ZodMiniString<string>;
+            currency: z.ZodMiniString<string>;
             decimals: z.ZodMiniNumber<number>;
             metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
             name: z.ZodMiniString<string>;
@@ -101,6 +114,7 @@ export declare namespace schema {
                 relay: "relay";
                 rhino: "rhino";
                 squid: "squid";
+                symbiosis: "symbiosis";
             }>;
             kind: z.ZodMiniString<string>;
             name: z.ZodMiniString<string>;
@@ -117,14 +131,12 @@ export declare namespace schema {
         }, z.core.$strip>;
         quote: z.ZodMiniObject<{
             expiresAt: z.ZodMiniOptional<z.ZodMiniISODateTime>;
-            inputAmount: z.ZodMiniString<string>;
-            minimumOutputAmount: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            outputAmount: z.ZodMiniString<string>;
-            outputAmountFormatted: z.ZodMiniString<string>;
             sampledAt: z.ZodMiniISODateTime;
         }, z.core.$strip>;
         sourceAmount: z.ZodMiniObject<{
-            amount: z.ZodMiniString<string>;
+            baseUnits: z.ZodMiniString<string>;
+            currency: z.ZodMiniString<string>;
+            decimals: z.ZodMiniNumber<number>;
             formatted: z.ZodMiniString<string>;
         }, z.core.$strip>;
         sourceChain: z.ZodMiniObject<{
@@ -144,6 +156,7 @@ export declare namespace schema {
         }, z.core.$strip>;
         sourceToken: z.ZodMiniObject<{
             address: z.ZodMiniString<string>;
+            currency: z.ZodMiniString<string>;
             decimals: z.ZodMiniNumber<number>;
             metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
             name: z.ZodMiniString<string>;
@@ -160,6 +173,7 @@ export declare namespace schema {
             relay: "relay";
             rhino: "rhino";
             squid: "squid";
+            symbiosis: "symbiosis";
         }>;
         kind: z.ZodMiniString<string>;
         name: z.ZodMiniString<string>;
@@ -186,6 +200,7 @@ export declare namespace schema {
         providerIds: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
         tokens: z.ZodMiniArray<z.ZodMiniObject<{
             address: z.ZodMiniString<string>;
+            currency: z.ZodMiniString<string>;
             decimals: z.ZodMiniNumber<number>;
             metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
             name: z.ZodMiniString<string>;
@@ -205,6 +220,7 @@ export declare namespace schema {
                 relay: "relay";
                 rhino: "rhino";
                 squid: "squid";
+                symbiosis: "symbiosis";
             }>>;
             sourceAmount: z.ZodMiniString<string>;
             sourceAmountUnits: z.ZodMiniDefault<z.ZodMiniEnum<{
@@ -217,6 +233,18 @@ export declare namespace schema {
         /** Non-paginated list of successful funding quotes. */
         const Response: z.ZodMiniObject<{
             data: z.ZodMiniArray<z.ZodMiniObject<{
+                destinationAmount: z.ZodMiniObject<{
+                    baseUnits: z.ZodMiniString<string>;
+                    currency: z.ZodMiniString<string>;
+                    decimals: z.ZodMiniNumber<number>;
+                    formatted: z.ZodMiniString<string>;
+                }, z.core.$strip>;
+                destinationAmountMin: z.ZodMiniOptional<z.ZodMiniObject<{
+                    baseUnits: z.ZodMiniString<string>;
+                    currency: z.ZodMiniString<string>;
+                    decimals: z.ZodMiniNumber<number>;
+                    formatted: z.ZodMiniString<string>;
+                }, z.core.$strip>>;
                 destinationChain: z.ZodMiniObject<{
                     addressFormat: z.ZodMiniEnum<{
                         base58: "base58";
@@ -234,6 +262,7 @@ export declare namespace schema {
                 }, z.core.$strip>;
                 destinationToken: z.ZodMiniObject<{
                     address: z.ZodMiniString<string>;
+                    currency: z.ZodMiniString<string>;
                     decimals: z.ZodMiniNumber<number>;
                     metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
                     name: z.ZodMiniString<string>;
@@ -249,6 +278,7 @@ export declare namespace schema {
                         relay: "relay";
                         rhino: "rhino";
                         squid: "squid";
+                        symbiosis: "symbiosis";
                     }>;
                     kind: z.ZodMiniString<string>;
                     name: z.ZodMiniString<string>;
@@ -265,14 +295,12 @@ export declare namespace schema {
                 }, z.core.$strip>;
                 quote: z.ZodMiniObject<{
                     expiresAt: z.ZodMiniOptional<z.ZodMiniISODateTime>;
-                    inputAmount: z.ZodMiniString<string>;
-                    minimumOutputAmount: z.ZodMiniOptional<z.ZodMiniString<string>>;
-                    outputAmount: z.ZodMiniString<string>;
-                    outputAmountFormatted: z.ZodMiniString<string>;
                     sampledAt: z.ZodMiniISODateTime;
                 }, z.core.$strip>;
                 sourceAmount: z.ZodMiniObject<{
-                    amount: z.ZodMiniString<string>;
+                    baseUnits: z.ZodMiniString<string>;
+                    currency: z.ZodMiniString<string>;
+                    decimals: z.ZodMiniNumber<number>;
                     formatted: z.ZodMiniString<string>;
                 }, z.core.$strip>;
                 sourceChain: z.ZodMiniObject<{
@@ -292,6 +320,7 @@ export declare namespace schema {
                 }, z.core.$strip>;
                 sourceToken: z.ZodMiniObject<{
                     address: z.ZodMiniString<string>;
+                    currency: z.ZodMiniString<string>;
                     decimals: z.ZodMiniNumber<number>;
                     metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
                     name: z.ZodMiniString<string>;
@@ -323,6 +352,7 @@ export declare namespace schema {
                 providerIds: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
                 tokens: z.ZodMiniArray<z.ZodMiniObject<{
                     address: z.ZodMiniString<string>;
+                    currency: z.ZodMiniString<string>;
                     decimals: z.ZodMiniNumber<number>;
                     metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
                     name: z.ZodMiniString<string>;
@@ -344,6 +374,7 @@ export declare namespace schema {
                     relay: "relay";
                     rhino: "rhino";
                     squid: "squid";
+                    symbiosis: "symbiosis";
                 }>;
                 kind: z.ZodMiniString<string>;
                 name: z.ZodMiniString<string>;
@@ -376,14 +407,14 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
         } | {
             output: {
                 error: {
-                    code: "api_key_malformed";
+                    code: "upstream_error";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 502;
             input: {
                 query: {
                     destinationToken?: string | string[];
@@ -397,14 +428,14 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
         } | {
             output: {
                 error: {
-                    code: "api_key_invalid" | "api_key_missing";
+                    code: "api_key_malformed";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 401;
+            status: 400;
             input: {
                 query: {
                     destinationToken?: string | string[];
@@ -418,14 +449,14 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
         } | {
             output: {
                 error: {
-                    code: "api_key_forbidden";
+                    code: "api_key_invalid" | "api_key_missing";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 403;
+            status: 401;
             input: {
                 query: {
                     destinationToken?: string | string[];
@@ -439,14 +470,14 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
         } | {
             output: {
                 error: {
-                    code: "payment_required" | "rate_limit_exceeded";
+                    code: "api_key_forbidden";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 429;
+            status: 403;
             input: {
                 query: {
                     destinationToken?: string | string[];
@@ -460,14 +491,14 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
         } | {
             output: {
                 error: {
-                    code: "query_invalid";
+                    code: "payment_required" | "rate_limit_exceeded";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 400;
+            status: 429;
             input: {
                 query: {
                     destinationToken?: string | string[];
@@ -481,14 +512,14 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
         } | {
             output: {
                 error: {
-                    code: "upstream_error";
+                    code: "query_invalid";
                     details?: readonly Response.error.Detail[] | undefined;
                     message: string;
                 };
                 requestId: string;
             };
             outputFormat: "json";
-            status: 502;
+            status: 400;
             input: {
                 query: {
                     destinationToken?: string | string[];
@@ -502,6 +533,18 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
         } | {
             output: {
                 data: {
+                    destinationAmount: {
+                        baseUnits: string;
+                        currency: string;
+                        decimals: number;
+                        formatted: string;
+                    };
+                    destinationAmountMin?: {
+                        baseUnits: string;
+                        currency: string;
+                        decimals: number;
+                        formatted: string;
+                    } | undefined;
                     destinationChain: {
                         addressFormat: "base58" | "base58check" | "evm";
                         id: string;
@@ -513,6 +556,7 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
                     };
                     destinationToken: {
                         address: string;
+                        currency: string;
                         decimals: number;
                         metadata: {
                             [x: string]: string;
@@ -525,7 +569,7 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
                     };
                     id: string;
                     provider: {
-                        id: "across" | "relay" | "rhino" | "squid";
+                        id: "across" | "relay" | "rhino" | "squid" | "symbiosis";
                         kind: string;
                         name: string;
                         requiresApiKey: boolean;
@@ -538,14 +582,12 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
                     };
                     quote: {
                         expiresAt?: string | undefined;
-                        inputAmount: string;
-                        minimumOutputAmount?: string | undefined;
-                        outputAmount: string;
-                        outputAmountFormatted: string;
                         sampledAt: string;
                     };
                     sourceAmount: {
-                        amount: string;
+                        baseUnits: string;
+                        currency: string;
+                        decimals: number;
                         formatted: string;
                     };
                     sourceChain: {
@@ -559,6 +601,7 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
                     };
                     sourceToken: {
                         address: string;
+                        currency: string;
                         decimals: number;
                         metadata: {
                             [x: string]: string;
@@ -652,6 +695,7 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
                     } | undefined;
                     tokens: {
                         address: string;
+                        currency: string;
                         decimals: number;
                         metadata: {
                             [x: string]: string;
@@ -727,7 +771,7 @@ export declare function funding(options?: funding.Options): import("hono/hono-ba
         } | {
             output: {
                 data: {
-                    id: "across" | "relay" | "rhino" | "squid";
+                    id: "across" | "relay" | "rhino" | "squid" | "symbiosis";
                     kind: string;
                     name: string;
                     requiresApiKey: boolean;

package/dist/apps/data/routes/funding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"funding.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/funding.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAG3C,OAAO,KAAK,aAAa,MAAM,oCAAoC,CAAA;AAEnE,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAIzD,oDAAoD;AACpD,yBAAiB,MAAM,CAAC;IACtB,6CAA6C;IACtC,MAAM,KAAK;;;;;;;;;;;;;;qBAiCjB,CAAA;IAED,6CAA6C;IACtC,MAAM,KAAK;;;;;;;;;qBA6CjB,CAAA;IAED,wDAAwD;IACjD,MAAM,WAAW;;;qBAevB,CAAA;IAED,oDAAoD;IAC7C,MAAM,WAAW;;;;;;;;;;qBAsBvB,CAAA;IAED,+EAA+E;IACxE,MAAM,OAAO;;;;;;;;qBA4BnB,CAAA;IAED,2DAA2D;IACpD,MAAM,YAAY;;;;;;;qBAuCxB,CAAA;IAED,qCAAqC;IAC9B,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkBxB,CAAA;IAED,4CAA4C;IACrC,MAAM,QAAQ;;;;;;;;;;;;;;qBA2BpB,CAAA;IAED,qEAAqE;IAC9D,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;qBAK1B,CAAA;IAED,8CAA8C;IAC9C,UAAiB,YAAY,CAAC;QAC5B,gDAAgD;QACzC,MAAM,KAAK;;;;;;;;;;;;;;;0BAoD0D,CAAA;QAE5E,uDAAuD;QAChD,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAKpB,CAAA;KACF;IAED,mDAAmD;IACnD,UAAiB,iBAAiB,CAAC;QACjC,4CAA4C;QACrC,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;yBAOpB,CAAA;KACF;IAED,+CAA+C;IAC/C,UAAiB,aAAa,CAAC;QAC7B,oDAAoD;QAC7C,MAAM,QAAQ;;;;;;;;;;;;;;;;yBAKpB,CAAA;KACF;CACF;AA4CD,2EAA2E;AAC3E,wBAAgB,OAAO,CAAC,OAAO,GAAE,OAAO,CAAC,OAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA4IpD;AAED,MAAM,CAAC,OAAO,WAAW,OAAO,CAAC;IAC/B,uCAAuC;IACvC,KAAK,OAAO,GAAG;QACb,qDAAqD;QACrD,QAAQ,CAAC,EAAE,aAAa,CAAC,gBAAgB,GAAG,SAAS,CAAA;QACrD,kDAAkD;QAClD,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KACtC,CAAA;CACF"}
+{"version":3,"file":"funding.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/funding.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAG3C,OAAO,KAAK,aAAa,MAAM,oCAAoC,CAAA;AAGnE,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAKzD,oDAAoD;AACpD,yBAAiB,MAAM,CAAC;IACtB,6CAA6C;IACtC,MAAM,KAAK;;;;;;;;;;;;;;qBAiCjB,CAAA;IAED,6CAA6C;IACtC,MAAM,KAAK;;;;;;;;;;qBAmDjB,CAAA;IAED,sEAAsE;IAC/D,MAAM,WAAW;;;;;qBAGvB,CAAA;IAED,oDAAoD;IAC7C,MAAM,WAAW;;;;;;;;;;;qBAsBvB,CAAA;IAED,+EAA+E;IACxE,MAAM,OAAO;;;;;;;;qBA4BnB,CAAA;IAED,qCAAqC;IAC9B,MAAM,YAAY;;;qBAgBxB,CAAA;IAED,qCAAqC;IAC9B,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BxB,CAAA;IAED,4CAA4C;IACrC,MAAM,QAAQ;;;;;;;;;;;;;;;qBA2BpB,CAAA;IAED,qEAAqE;IAC9D,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;qBAK1B,CAAA;IAED,8CAA8C;IAC9C,UAAiB,YAAY,CAAC;QAC5B,gDAAgD;QACzC,MAAM,KAAK;;;;;;;;;;;;;;;;0BAoD0D,CAAA;QAE5E,uDAAuD;QAChD,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAKpB,CAAA;KACF;IAED,mDAAmD;IACnD,UAAiB,iBAAiB,CAAC;QACjC,4CAA4C;QACrC,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAOpB,CAAA;KACF;IAED,+CAA+C;IAC/C,UAAiB,aAAa,CAAC;QAC7B,oDAAoD;QAC7C,MAAM,QAAQ;;;;;;;;;;;;;;;;;yBAKpB,CAAA;KACF;CACF;AA4DD,2EAA2E;AAC3E,wBAAgB,OAAO,CAAC,OAAO,GAAE,OAAO,CAAC,OAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAiJpD;AAED,MAAM,CAAC,OAAO,WAAW,OAAO,CAAC;IAC/B,uCAAuC;IACvC,KAAK,OAAO,GAAG;QACb,qDAAqD;QACrD,QAAQ,CAAC,EAAE,aAAa,CAAC,gBAAgB,GAAG,SAAS,CAAA;QACrD,kDAAkD;QAClD,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KACtC,CAAA;CACF"}

package/dist/apps/data/routes/funding.js

@@ -6,6 +6,7 @@ import * as FundingQuotes from '../../../internal/FundingQuotes.js';
 import * as OpenApi from '../../../internal/OpenApi.js';
 import * as Response from '../../../internal/Response.js';
 import * as Schema from '../../../internal/Schema.js';
+import * as Value from '../../../internal/Value.js';
 import * as FundingQuoteProviders from '../FundingQuoteProviders.js';
 /** Zod schemas owned by funding quote resources. */
 export var schema;
@@ -33,6 +34,9 @@ export var schema;
         address: z
             .string()
             .check(z.describe('Contract address, mint, or issuer address on the token chain.'), z.meta({ examples: ['0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'] })),
+        currency: z
+            .string()
+            .check(z.describe('Monetary denomination represented by this token.'), z.meta({ examples: ['USD'] })),
         decimals: z
             .number()
             .check(z.int(), z.gte(0), z.describe('Number of decimal places this token uses.'), z.meta({ examples: [6] })),
@@ -55,17 +59,12 @@ export var schema;
             .boolean()
             .check(z.describe('Whether Tempo recognizes this token in its funding quote inventory.'), z.meta({ examples: [true] })),
     }), 'A normalized token reference for funding quotes.');
-    /** Source amount echoed by a funding quote response. */
-    schema.TokenAmount = Schema.describe(z.object({
-        amount: Schema.DecimalString.check(z.describe("The requested source amount in the token's smallest unit.")),
-        formatted: z
-            .string()
-            .check(z.describe('The same amount in human-readable decimal form, using the source token’s `decimals`.'), z.meta({ examples: ['1'] })),
-    }), 'The requested source amount in provider-safe base units and display form.');
+    /** Self-contained source or destination amount in a funding quote. */
+    schema.TokenAmount = Schema.describe(Schema.TokenAmount, 'A funding amount in base units and human-readable form.');
     /** Provider summary embedded in a funding quote. */
     schema.ProviderRef = Schema.describe(z.object({
         id: z
-            .enum(['across', 'relay', 'rhino', 'squid'])
+            .enum(['across', 'relay', 'rhino', 'squid', 'symbiosis'])
             .check(z.describe('Stable provider id.'), z.meta({ examples: ['relay'] })),
         kind: z
             .string()
@@ -92,28 +91,21 @@ export var schema;
             .enum(['liquid', 'thin'])
             .check(z.describe('Machine-readable quality tier for a successful quote.'), z.meta({ examples: ['liquid'] })),
     }), 'Machine-readable liquidity, fee, and source signals for a successful quote.');
-    /** Provider-derived output, limits, and freshness data. */
+    /** Provider quote freshness data. */
     schema.QuoteDetails = Schema.describe(z.object({
         expiresAt: z
             .optional(z.iso.datetime())
             .check(z.describe('Timestamp after which the provider quote is no longer valid.'), z.meta({ examples: ['2026-01-01T00:01:00Z'] })),
-        inputAmount: Schema.DecimalString.check(z.describe('Source amount sent to the provider in base units.'), z.meta({ examples: ['1000000'] })),
-        minimumOutputAmount: z
-            .optional(Schema.DecimalString)
-            .check(z.describe('Slippage-adjusted minimum destination amount in base units.'), z.meta({ examples: ['988000'] })),
-        outputAmount: z
-            .string()
-            .check(z.regex(/^\d+$/))
-            .check(z.describe('Expected destination amount in base units.'), z.meta({ examples: ['989102'] })),
-        outputAmountFormatted: z
-            .string()
-            .check(z.describe('Expected destination amount rendered with destination token decimals.'), z.meta({ examples: ['0.989102'] })),
         sampledAt: z.iso
             .datetime()
             .check(z.describe('Timestamp for the live quote probe.'), z.meta({ examples: ['2026-01-01T00:00:00Z'] })),
-    }), 'Provider-derived output, limits, and freshness data for a funding quote.');
+    }), 'Freshness data for a provider funding quote.');
     /** Successful live funding quote. */
     schema.FundingQuote = Schema.describe(z.object({
+        destinationAmount: schema.TokenAmount.check(z.describe('Expected destination amount.')),
+        destinationAmountMin: z
+            .optional(schema.TokenAmount)
+            .check(z.describe('Provider-derived minimum destination amount. Symbiosis and Squid quotes use a fixed 1% slippage tolerance.')),
         destinationChain: schema.Chain.check(z.describe('Destination chain, always Tempo mainnet in V1.')),
         destinationToken: schema.Token.check(z.describe('Tempo token expected from this quote.')),
         id: z
@@ -129,7 +121,7 @@ export var schema;
     /** Funding quote provider catalog entry. */
     schema.Provider = Schema.describe(z.object({
         id: z
-            .enum(['across', 'relay', 'rhino', 'squid'])
+            .enum(['across', 'relay', 'rhino', 'squid', 'symbiosis'])
             .check(z.describe('Stable provider id.'), z.meta({ examples: ['relay'] })),
         kind: z
             .string()
@@ -158,8 +150,8 @@ export var schema;
                 .optional(z.string())
                 .check(z.describe('Tempo destination token symbol, address, or token key. Defaults to USDC.e.'), z.meta({ examples: ['USDC.e'] })),
             provider: z
-                .optional(z.enum(['across', 'relay', 'rhino', 'squid']))
-                .check(z.describe('Only request a quote from this provider. Supported ids are `across`, `relay`, `rhino`, and `squid`; omit it to query every configured provider.'), z.meta({ examples: ['relay'] })),
+                .optional(z.enum(['across', 'relay', 'rhino', 'squid', 'symbiosis']))
+                .check(z.describe('Only request a quote from this provider. Supported ids are `across`, `relay`, `rhino`, `squid`, and `symbiosis`; omit it to query every configured provider.'), z.meta({ examples: ['relay'] })),
             sourceAmount: z
                 .string()
                 .check(z.regex(/^(?=.*[1-9])\d+(\.\d+)?$/), z.describe('Positive source token amount. Base units by default, so 1 USDC is `1000000`.'), z.meta({ examples: ['1000000'] })),
@@ -211,7 +203,20 @@ const fundingQuoteResponseExample = (() => {
     return {
         data: [
             {
-                ...candidate,
+                destinationAmount: Value.tokenAmount({
+                    baseUnits: '979295',
+                    currency: candidate.destinationToken.currency,
+                    decimals: candidate.destinationToken.decimals,
+                }),
+                destinationAmountMin: Value.tokenAmount({
+                    baseUnits: '939242',
+                    currency: candidate.destinationToken.currency,
+                    decimals: candidate.destinationToken.decimals,
+                }),
+                destinationChain: candidate.destinationChain,
+                destinationToken: candidate.destinationToken,
+                id: candidate.id,
+                provider: candidate.provider,
                 quality: {
                     estimatedSeconds: 1,
                     liquiditySource: 'providerQuote',
@@ -219,12 +224,15 @@ const fundingQuoteResponseExample = (() => {
                     tier: 'liquid',
                 },
                 quote: {
-                    inputAmount: '1000000',
-                    minimumOutputAmount: '939242',
-                    outputAmount: '979295',
-                    outputAmountFormatted: '0.979295',
                     sampledAt: '2026-01-01T00:00:00.000Z',
                 },
+                sourceAmount: Value.tokenAmount({
+                    baseUnits: candidate.sourceAmount.amount,
+                    currency: candidate.sourceToken.currency,
+                    decimals: candidate.sourceToken.decimals,
+                }),
+                sourceChain: candidate.sourceChain,
+                sourceToken: candidate.sourceToken,
             },
         ],
     };
@@ -245,7 +253,7 @@ export function funding(options = {}) {
         code: 'query_invalid',
         message: 'Invalid query parameters',
     }), OpenApi.describeRoute({
-        description: 'Returns live quotes for funding Tempo with a stablecoin. Omit `provider` to query all configured providers. This endpoint does not execute a transfer.',
+        description: 'Returns live quotes for funding Tempo with a stablecoin. Omit `provider` to query all configured providers. Provider minimums can use provider-specific slippage policies; Symbiosis and Squid use 1%. This endpoint does not execute a transfer.',
         operationId: 'quoteFunding',
         responses: OpenApi.responses({
             errors: {
@@ -272,6 +280,7 @@ export function funding(options = {}) {
                 message: 'Invalid query parameters',
             });
         const query = c.req.valid('query');
+        const attempts = [];
         try {
             c.header('Cache-Control', 'no-store');
             return c.json(Response.validated(schema.quoteFunding.Response, {
@@ -280,6 +289,7 @@ export function funding(options = {}) {
                     adapterTimeoutMs: options.adapterTimeoutMs,
                     cache: { bypass: cacheBypass(c.req.raw) },
                     destinationToken: query.destinationToken,
+                    onAttempt: (attempt) => attempts.push(attempt),
                     provider: query.provider,
                     sourceAmount: query.sourceAmount,
                     sourceAmountUnits: query.sourceAmountUnits,
@@ -307,6 +317,10 @@ export function funding(options = {}) {
             }
             throw cause;
         }
+        finally {
+            if (attempts.length > 0)
+                c.set('fundingProviderAttempts', attempts.map(fundingProviderAttempt));
+        }
     })
         .get('/v1/funding/chains', Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }), OpenApi.describeRoute({
         description: 'Lists the source chains and stablecoins you can use when requesting a funding quote.',
@@ -322,7 +336,7 @@ export function funding(options = {}) {
         tags: ['Funding'],
     }), Cache.response({
         cacheControl: Cache.policies.stable,
-        name: 'tempo-api:funding-chains:v1',
+        name: 'tempo-api:funding-chains:v2',
         key: (c) => c.req.url,
     }), (c) => {
         if (Auth.narrowAccess)
@@ -355,6 +369,26 @@ export function funding(options = {}) {
         }), 200);
     });
 }
+function fundingProviderAttempt(attempt) {
+    const operation = FundingQuoteProviders.providerOperation(attempt.provider);
+    if (attempt.outcome !== 'failed')
+        return {
+            durationMs: attempt.durationMs,
+            id: attempt.provider,
+            operation,
+            outcome: attempt.outcome,
+        };
+    return {
+        durationMs: attempt.durationMs,
+        failure: FundingQuoteProviders.providerFailure({
+            cause: attempt.cause,
+            provider: attempt.provider,
+        }).failure,
+        id: attempt.provider,
+        operation,
+        outcome: attempt.outcome,
+    };
+}
 // Maps caller-input errors to a specific 400 message; anything else rethrows.
 function requestErrorMessage(cause) {
     if (cause instanceof FundingQuotes.InvalidAmountError)