@argent/x-shared 1.64.0 → 1.66.0

package/dist/src/features/simulation/transactionReview/schema.js

@@ -1,12 +1,12 @@
 import { z as t } from "zod";
-import { estimatedFeesSchema as h, estimatedFeesV2Schema as y } from "../fees/schema.js";
-import { severitySchema as f, reasonsSchema as j } from "../warning/schema.js";
-import { addressSchemaArgentBackend as n, addressSchema as k } from "../../../chains/starknet/address.js";
-const v = t.object({
+import { estimatedFeesSchema as y, estimatedFeesV2Schema as f } from "../fees/schema.js";
+import { severitySchema as j, reasonsSchema as k } from "../warning/schema.js";
+import { addressSchemaArgentBackend as n, addressSchema as v } from "../../../chains/starknet/address.js";
+const w = t.object({
   name: t.string(),
   url: t.string(),
   position: t.number()
-}), o = t.object({
+}), e = t.object({
   address: t.string(),
   name: t.string(),
   symbol: t.string().optional(),
@@ -14,11 +14,11 @@ const v = t.object({
   unknown: t.boolean(),
   iconUrl: t.string().optional(),
   type: t.string()
-}), l = t.discriminatedUnion("type", [
+}), c = t.discriminatedUnion("type", [
   t.object({
     type: t.literal("amount"),
     label: t.string(),
-    token: o,
+    token: e,
     amount: t.string(),
     usd: t.string(),
     editable: t.boolean()
@@ -39,7 +39,7 @@ const v = t.object({
   t.object({
     type: t.literal("token_address"),
     label: t.string(),
-    token: o
+    token: e
   }),
   t.object({
     type: t.literal("calldata"),
@@ -60,42 +60,42 @@ const v = t.object({
   t.object({
     type: t.literal("nft"),
     label: t.string(),
-    token: o
+    token: e
   })
-]), w = t.object({
+]), E = t.object({
   name: t.string(),
-  properties: t.array(l),
-  defaultProperties: t.array(l).optional()
-}), E = t.union([
+  properties: t.array(c),
+  defaultProperties: t.array(c).optional()
+}), F = t.union([
   t.literal("verified"),
   t.literal("neutral"),
   t.literal("partial"),
   t.literal("warn")
-]), F = t.object({
+]), U = t.object({
   unknown_token: t.unknown().optional(),
   date_of_addition: t.string().optional(),
-  contract_address: k.optional(),
+  contract_address: v.optional(),
   reason: t.string().optional(),
   value: t.string().or(t.number()).optional()
-}), c = t.object({
-  reason: j,
-  details: F.optional(),
-  severity: f
-}), U = t.object({
-  assessment: E,
-  warnings: t.array(c).optional(),
+}), p = t.object({
+  reason: k,
+  details: U.optional(),
+  severity: j
+}), x = t.object({
+  assessment: F,
+  warnings: t.array(p).optional(),
   assessmentReasons: t.array(t.string()).optional(),
   assessmentDetails: t.object({
     contract_address: t.string()
   }).optional(),
-  action: w
-}), x = t.object({
+  action: E
+}), D = t.object({
   name: t.string(),
   description: t.string(),
   logoUrl: t.string().optional(),
   iconUrl: t.string().optional(),
   argentVerified: t.boolean(),
-  links: t.array(v)
+  links: t.array(w)
 }), m = t.object({
   assessment: t.union([
     t.literal("verified"),
@@ -103,18 +103,18 @@ const v = t.object({
     t.literal("partial"),
     t.literal("warn")
   ]),
-  warnings: t.array(c).optional(),
+  warnings: t.array(p).optional(),
   assessmentDetails: t.object({
     contract_address: t.string()
   }).optional(),
-  targetedDapp: x.optional(),
-  reviews: t.array(U)
-}).optional(), p = t.object({
+  targetedDapp: D.optional(),
+  reviews: t.array(x)
+}).optional(), d = t.object({
   banner: t.string().nullable().optional(),
   preview: t.string().nullable().optional(),
   full: t.string().nullable().optional(),
   original: t.string().nullable().optional()
-}), D = t.object({
+}), A = t.object({
   twitter: t.string().optional(),
   external: t.string().optional(),
   discord: t.string().optional()
@@ -128,47 +128,47 @@ const v = t.object({
   usdValue: t.string().optional(),
   iconUrl: t.string().optional(),
   unknown: t.boolean().optional(),
-  imageUrls: p.optional(),
-  links: D.optional()
-}), A = t.object({
+  imageUrls: d.optional(),
+  links: A.optional()
+}), T = t.object({
   tokenAddress: n,
   owner: n,
   spender: n,
   value: t.string().optional(),
   approvalForAll: t.boolean(),
   details: i.optional()
-}), T = t.object({
+}), P = t.object({
   tokenAddress: n,
   from: n,
   to: n,
   tokenId: t.string().optional(),
   value: t.string().optional(),
   details: i.optional()
-}), a = t.union([t.string(), t.number(), t.bigint()]).transform((e) => parseInt(e.toString(), 10)), d = {
-  overallFee: a,
-  gasPrice: a,
-  gasUsage: a,
-  dataGasPrice: a.optional(),
-  dataGasConsumed: a.optional()
-}, P = t.object({
-  ...d,
-  unit: t.string().transform((e) => e.toUpperCase()).pipe(t.literal("WEI")),
-  maxFee: a
-}), g = t.object({
+}), o = t.union([t.string(), t.number(), t.bigint()]).transform((a) => parseInt(a.toString(), 10)), g = {
+  overallFee: o,
+  gasPrice: o,
+  gasUsage: o,
+  dataGasPrice: o.optional(),
+  dataGasConsumed: o.optional()
+}, _ = t.object({
+  ...g,
+  unit: t.string().transform((a) => a.toUpperCase()).pipe(t.literal("WEI")),
+  maxFee: o
+}), b = t.object({
   address: n,
   unknown: t.boolean(),
   type: t.literal("ERC20")
-}), _ = t.object({
-  ...d,
-  unit: t.string().transform((e) => e.toUpperCase()).pipe(t.literal("FRI")),
-  maxAmount: a,
-  maxPricePerUnit: a,
-  token: g
 }), V = t.object({
-  token: g,
-  overallFee: a,
-  maxFee: a
-}), b = P.or(_), I = b.or(V), N = t.object({
+  ...g,
+  unit: t.string().transform((a) => a.toUpperCase()).pipe(t.literal("FRI")),
+  maxAmount: o,
+  maxPricePerUnit: o,
+  token: b
+}), I = t.object({
+  token: b,
+  overallFee: o,
+  maxFee: o
+}), u = _.or(V), N = u.or(I), R = t.object({
   type: t.string(),
   label: t.string(),
   tokenId: t.string().optional(),
@@ -179,69 +179,77 @@ const v = t.object({
   tokenIdDetails: t.object({
     name: t.string().optional(),
     description: t.string().optional(),
-    imageUrls: p.optional()
+    imageUrls: d.optional()
   }).optional()
-}), R = t.object({
-  approvals: t.array(A).optional(),
-  transfers: t.array(T).optional(),
-  calculatedNonce: t.string().optional(),
-  feeEstimation: b,
-  feeEstimations: t.array(I),
-  summary: t.array(N).optional()
 }), C = t.object({
+  approvals: t.array(T).optional(),
+  transfers: t.array(P).optional(),
+  calculatedNonce: t.string().optional(),
+  feeEstimation: u,
+  feeEstimations: t.array(N),
+  summary: t.array(R).optional()
+}), O = t.object({
   label: t.string().optional(),
   code: t.number().optional(),
   message: t.string().optional(),
   error: t.string().optional()
-}), u = t.object({
+}), S = t.object({
   reviewOfTransaction: m,
-  simulation: R,
+  simulation: C,
   simulationError: t.undefined()
-}), S = t.object({
+}), h = t.object({
   reviewOfTransaction: m,
   simulation: t.undefined(),
-  simulationError: C
-}), s = u.or(S), r = t.object({
+  simulationError: O
+}), s = S.or(h), r = t.object({
   subsidiseDeployment: t.boolean(),
   subsidiseTransaction: t.boolean()
-}), H = t.object({
+}), B = t.object({
+  name: t.string().optional(),
+  shouldShow: t.boolean().optional()
+}), l = t.array(B), q = t.object({
   transactions: t.array(s).optional(),
-  subsidyStatus: r.optional()
-}), W = t.object({
+  subsidyStatus: r.optional(),
+  promotions: l.optional()
+}), J = t.object({
   transactions: t.array(s).optional(),
   subsidyStatus: r.optional(),
-  enrichedFeeEstimation: h.optional(),
-  isBackendDown: t.boolean().default(!1).optional()
-}), q = t.object({
+  enrichedFeeEstimation: y.optional(),
+  isBackendDown: t.boolean().default(!1).optional(),
+  promotions: l.optional()
+}), K = t.object({
   transactions: t.array(s).optional(),
   subsidyStatus: r.optional(),
-  enrichedFeeEstimation: t.array(y).optional(),
-  isBackendDown: t.boolean().default(!1).optional()
+  enrichedFeeEstimation: t.array(f).optional(),
+  isBackendDown: t.boolean().default(!1).optional(),
+  promotions: l.optional()
 });
-function J(e) {
-  return u.safeParse(e).success;
+function L(a) {
+  return S.safeParse(a).success;
 }
-function K(e) {
-  return S.safeParse(e).success;
+function M(a) {
+  return h.safeParse(a).success;
 }
 export {
-  w as actionSchema,
-  E as assessmentSchema,
-  W as enrichedSimulateAndReviewSchema,
-  q as enrichedSimulateAndReviewV2Schema,
-  I as feeEstimationNativeOrPaymasterSchema,
-  b as feeEstimationSchema,
-  P as feeEstimationTxV1Schema,
-  _ as feeEstimationTxV3Schema,
-  J as isNotTransactionSimulationError,
-  K as isTransactionSimulationError,
-  V as paymasterFeeEstimationSchema,
-  g as paymasterFeeTokenSchema,
-  l as propertySchema,
-  U as reviewSchema,
-  H as simulateAndReviewSchema,
+  E as actionSchema,
+  F as assessmentSchema,
+  J as enrichedSimulateAndReviewSchema,
+  K as enrichedSimulateAndReviewV2Schema,
+  N as feeEstimationNativeOrPaymasterSchema,
+  u as feeEstimationSchema,
+  _ as feeEstimationTxV1Schema,
+  V as feeEstimationTxV3Schema,
+  L as isNotTransactionSimulationError,
+  M as isTransactionSimulationError,
+  I as paymasterFeeEstimationSchema,
+  b as paymasterFeeTokenSchema,
+  B as promotionSchema,
+  l as promotionsSchema,
+  c as propertySchema,
+  x as reviewSchema,
+  q as simulateAndReviewSchema,
   r as subsidyStatusSchema,
-  x as targetedDappSchema,
-  F as warningDetailsSchema,
-  c as warningSchema
+  D as targetedDappSchema,
+  U as warningDetailsSchema,
+  p as warningSchema
 };

package/dist/src/features/swap/models/execute.model.d.ts

@@ -0,0 +1,35 @@
+import { AllowArray, BigNumberish, CairoVersion, Call, Signature, TransactionType, UniversalDetails } from 'starknet';
+interface ApiResourceBounds {
+    l1Gas: {
+        maxAmount?: string;
+        maxPricePerUnit?: string;
+    };
+    l2Gas: {
+        maxAmount?: string;
+        maxPricePerUnit?: string;
+    };
+}
+export type SwapTransactionParams = UniversalDetails & {
+    type: typeof TransactionType.INVOKE;
+    calls: AllowArray<Call>;
+    chainId: string;
+    cairoVersion: CairoVersion;
+    account: string;
+    signature: Signature;
+};
+export type ApiSwapRequest = {
+    type: typeof TransactionType.INVOKE;
+    calls: AllowArray<Call>;
+    chainId: string;
+    cairoVersion: CairoVersion;
+    account: string;
+    signature: Signature;
+    nonce?: BigNumberish;
+    maxFee?: BigNumberish;
+    tip?: BigNumberish;
+    version?: BigNumberish;
+    nonceDataAvailabilityMode?: string;
+    feeDataAvailabilityMode?: string;
+    resourceBounds?: ApiResourceBounds;
+};
+export {};

package/dist/src/features/swap/models/index.d.ts

@@ -1,3 +1,4 @@
 export * from './order.model';
 export * from './quote.model';
 export * from './trade.model';
+export type * from './execute.model';

package/dist/src/features/swap/services/ISwapTransactionService.d.ts

@@ -0,0 +1,10 @@
+import { TransactionExecutionResponse } from '../../../transactions/transactionExecuteTypes';
+import { SwapTransactionParams } from '../models/execute.model';
+import { PaymasterExecuteParams } from './../../paymaster/types';
+export interface ISwapTransactionService {
+    execute({ paymasterParams, transactionParams, isSubsidised, }: {
+        paymasterParams?: PaymasterExecuteParams;
+        transactionParams?: SwapTransactionParams[];
+        isSubsidised?: boolean;
+    }): Promise<TransactionExecutionResponse>;
+}

package/dist/src/features/swap/services/{implementation.d.ts → SwapSharedService.d.ts}

@@ -2,7 +2,7 @@ import { Address } from '../../../chains';
 import { SwapOrderResponse, SwapQuoteResponse, Trade } from '../models';
 import { IHttpService } from '../../../http';
 import { WebToken } from '../../../tokens/service/types/webToken.model';
-import { ISharedSwapService } from './interface';
+import { ISharedSwapService } from './ISwapSharedService';
 export declare class SharedSwapService implements ISharedSwapService {
     private readonly httpService;
     swapQuoteUrl: string;

package/dist/src/features/swap/services/SwapTransactionService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const y=require("lodash-es"),v=require("starknet"),A=require("../../../transactions/transactionExecuteTypes.cjs"),_=require("../../../../node_modules/.pnpm/@starknet-io_types-js@0.7.7/node_modules/@starknet-io/types-js/dist/esm/api/nonspec.cjs");class S{constructor(n="",t){this.argentAffiliateUrl=n,this.httpService=t}async execute({paymasterParams:n,transactionParams:t,isSubsidised:g}){if(y.isEmpty(this.argentAffiliateUrl))throw new Error("Argent affiliate URL is not set");let o;n?o={executeRequest:{...n,signature:n.signature,deploymentData:n.deploymentData,userAddress:n.accountAddress,typedData:n.typedData},isSubsidised:g}:o={transactions:t==null?void 0:t.map(e=>{var c,r,u,l,a,d,p,f;const i={type:e.type,calls:e.calls,chainId:e.chainId,cairoVersion:e.cairoVersion,account:e.account,signature:e.signature,nonce:e.nonce,version:e.version};return e.version===_.ETransactionVersion.V1?i.maxFee=e.maxFee:(i.resourceBounds={l1Gas:{maxAmount:(r=(c=e.resourceBounds)==null?void 0:c.l1_gas)==null?void 0:r.max_amount,maxPricePerUnit:(l=(u=e.resourceBounds)==null?void 0:u.l1_gas)==null?void 0:l.max_price_per_unit},l2Gas:{maxAmount:(d=(a=e.resourceBounds)==null?void 0:a.l2_gas)==null?void 0:d.max_amount,maxPricePerUnit:(f=(p=e.resourceBounds)==null?void 0:p.l2_gas)==null?void 0:f.max_price_per_unit}},i.nonceDataAvailabilityMode=e.nonceDataAvailabilityMode,i.feeDataAvailabilityMode=e.feeDataAvailabilityMode,i.tip=e.tip),i})};const h=await this.httpService.post(this.argentAffiliateUrl,{body:v.json.stringify(o),headers:{"Content-Type":"application/json"}}),s=A.transactionExecutionResponseSchema.safeParse(h);if(!s.success)throw new Error("Invalid response from swap API");return s.data}}exports.SwapTransactionService=S;

package/dist/src/features/swap/services/SwapTransactionService.d.ts

@@ -0,0 +1,15 @@
+import { IHttpService } from '../../../http';
+import { TransactionExecutionResponse } from '../../../transactions/transactionExecuteTypes';
+import { SwapTransactionParams } from '../models/execute.model';
+import { PaymasterExecuteParams } from './../../paymaster/types';
+import { ISwapTransactionService } from './ISwapTransactionService';
+export declare class SwapTransactionService implements ISwapTransactionService {
+    private readonly argentAffiliateUrl;
+    private readonly httpService;
+    constructor(argentAffiliateUrl: string | undefined, httpService: IHttpService);
+    execute({ paymasterParams, transactionParams, isSubsidised, }: {
+        paymasterParams?: PaymasterExecuteParams;
+        transactionParams?: SwapTransactionParams[];
+        isSubsidised?: boolean;
+    }): Promise<TransactionExecutionResponse>;
+}

package/dist/src/features/swap/services/SwapTransactionService.js

@@ -0,0 +1,60 @@
+import { isEmpty as A } from "lodash-es";
+import { json as _ } from "starknet";
+import { transactionExecutionResponseSchema as v } from "../../../transactions/transactionExecuteTypes.js";
+import { ETransactionVersion as y } from "../../../../node_modules/.pnpm/@starknet-io_types-js@0.7.7/node_modules/@starknet-io/types-js/dist/esm/api/nonspec.js";
+class R {
+  constructor(i = "", n) {
+    this.argentAffiliateUrl = i, this.httpService = n;
+  }
+  async execute({ paymasterParams: i, transactionParams: n, isSubsidised: g }) {
+    if (A(this.argentAffiliateUrl))
+      throw new Error("Argent affiliate URL is not set");
+    let t;
+    i ? t = {
+      executeRequest: {
+        ...i,
+        signature: i.signature,
+        deploymentData: i.deploymentData,
+        userAddress: i.accountAddress,
+        typedData: i.typedData
+      },
+      isSubsidised: g
+    } : t = {
+      transactions: n == null ? void 0 : n.map((e) => {
+        var c, r, l, u, p, d, a, f;
+        const o = {
+          type: e.type,
+          calls: e.calls,
+          chainId: e.chainId,
+          cairoVersion: e.cairoVersion,
+          account: e.account,
+          signature: e.signature,
+          nonce: e.nonce,
+          version: e.version
+        };
+        return e.version === y.V1 ? o.maxFee = e.maxFee : (o.resourceBounds = {
+          l1Gas: {
+            maxAmount: (r = (c = e.resourceBounds) == null ? void 0 : c.l1_gas) == null ? void 0 : r.max_amount,
+            maxPricePerUnit: (u = (l = e.resourceBounds) == null ? void 0 : l.l1_gas) == null ? void 0 : u.max_price_per_unit
+          },
+          l2Gas: {
+            maxAmount: (d = (p = e.resourceBounds) == null ? void 0 : p.l2_gas) == null ? void 0 : d.max_amount,
+            maxPricePerUnit: (f = (a = e.resourceBounds) == null ? void 0 : a.l2_gas) == null ? void 0 : f.max_price_per_unit
+          }
+        }, o.nonceDataAvailabilityMode = e.nonceDataAvailabilityMode, o.feeDataAvailabilityMode = e.feeDataAvailabilityMode, o.tip = e.tip), o;
+      })
+    };
+    const h = await this.httpService.post(this.argentAffiliateUrl, {
+      body: _.stringify(t),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    }), s = v.safeParse(h);
+    if (!s.success)
+      throw new Error("Invalid response from swap API");
+    return s.data;
+  }
+}
+export {
+  R as SwapTransactionService
+};

package/dist/src/features/swap/services/index.d.ts

@@ -1,2 +1,4 @@
-export * from './implementation';
-export type * from './interface';
+export * from './SwapSharedService';
+export type * from './ISwapSharedService';
+export * from './SwapTransactionService';
+export type * from './ISwapTransactionService';

package/dist/src/transactions/index.d.ts

@@ -14,3 +14,4 @@ export type * from './transactionSimulationTypes';
 export * from './transactionVersion';
 export * from './txv3';
 export type * from './types';
+export * from './transactionExecuteTypes';

package/dist/src/transactions/transactionExecuteTypes.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),o=t.z.object({tokenType:t.z.string(),tokenAddress:t.z.string(),tokenAmount:t.z.string()}),n=t.z.object({type:t.z.enum(["lootbox"]),status:t.z.enum(["notEligible","win","loss","disabled"]),prizes:t.z.array(o).nullable().optional()}),e=t.z.object({transactionState:t.z.enum(["submitted","rejected"]).optional(),transactionHash:t.z.string(),rejectReason:t.z.string().nullable().optional(),promotions:t.z.array(n).nullable().optional()});exports.transactionExecutionResponseSchema=e;exports.transactionPromotionPrizeSchema=o;exports.transactionPromotionSchema=n;

package/dist/src/transactions/transactionExecuteTypes.d.ts

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+export declare const transactionPromotionPrizeSchema: z.ZodObject<{
+    tokenType: z.ZodString;
+    tokenAddress: z.ZodString;
+    tokenAmount: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    tokenAddress: string;
+    tokenType: string;
+    tokenAmount: string;
+}, {
+    tokenAddress: string;
+    tokenType: string;
+    tokenAmount: string;
+}>;
+export declare const transactionPromotionSchema: z.ZodObject<{
+    type: z.ZodEnum<["lootbox"]>;
+    status: z.ZodEnum<["notEligible", "win", "loss", "disabled"]>;
+    prizes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        tokenType: z.ZodString;
+        tokenAddress: z.ZodString;
+        tokenAmount: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        tokenAddress: string;
+        tokenType: string;
+        tokenAmount: string;
+    }, {
+        tokenAddress: string;
+        tokenType: string;
+        tokenAmount: string;
+    }>, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    type: "lootbox";
+    status: "notEligible" | "win" | "loss" | "disabled";
+    prizes?: {
+        tokenAddress: string;
+        tokenType: string;
+        tokenAmount: string;
+    }[] | null | undefined;
+}, {
+    type: "lootbox";
+    status: "notEligible" | "win" | "loss" | "disabled";
+    prizes?: {
+        tokenAddress: string;
+        tokenType: string;
+        tokenAmount: string;
+    }[] | null | undefined;
+}>;
+export declare const transactionExecutionResponseSchema: z.ZodObject<{
+    transactionState: z.ZodOptional<z.ZodEnum<["submitted", "rejected"]>>;
+    transactionHash: z.ZodString;
+    rejectReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    promotions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["lootbox"]>;
+        status: z.ZodEnum<["notEligible", "win", "loss", "disabled"]>;
+        prizes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            tokenType: z.ZodString;
+            tokenAddress: z.ZodString;
+            tokenAmount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            tokenAddress: string;
+            tokenType: string;
+            tokenAmount: string;
+        }, {
+            tokenAddress: string;
+            tokenType: string;
+            tokenAmount: string;
+        }>, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "lootbox";
+        status: "notEligible" | "win" | "loss" | "disabled";
+        prizes?: {
+            tokenAddress: string;
+            tokenType: string;
+            tokenAmount: string;
+        }[] | null | undefined;
+    }, {
+        type: "lootbox";
+        status: "notEligible" | "win" | "loss" | "disabled";
+        prizes?: {
+            tokenAddress: string;
+            tokenType: string;
+            tokenAmount: string;
+        }[] | null | undefined;
+    }>, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    transactionHash: string;
+    promotions?: {
+        type: "lootbox";
+        status: "notEligible" | "win" | "loss" | "disabled";
+        prizes?: {
+            tokenAddress: string;
+            tokenType: string;
+            tokenAmount: string;
+        }[] | null | undefined;
+    }[] | null | undefined;
+    transactionState?: "rejected" | "submitted" | undefined;
+    rejectReason?: string | null | undefined;
+}, {
+    transactionHash: string;
+    promotions?: {
+        type: "lootbox";
+        status: "notEligible" | "win" | "loss" | "disabled";
+        prizes?: {
+            tokenAddress: string;
+            tokenType: string;
+            tokenAmount: string;
+        }[] | null | undefined;
+    }[] | null | undefined;
+    transactionState?: "rejected" | "submitted" | undefined;
+    rejectReason?: string | null | undefined;
+}>;
+export type TransactionExecutionResponse = z.infer<typeof transactionExecutionResponseSchema>;
+export type TransactionPromotion = z.infer<typeof transactionPromotionSchema>;
+export type TransactionPromotionPrize = z.infer<typeof transactionPromotionPrizeSchema>;

package/dist/src/transactions/transactionExecuteTypes.js

@@ -0,0 +1,23 @@
+import { z as t } from "zod";
+const o = t.object({
+  tokenType: t.string(),
+  tokenAddress: t.string(),
+  tokenAmount: t.string()
+}), n = t.object({
+  type: t.enum(["lootbox"]),
+  status: t.enum(["notEligible", "win", "loss", "disabled"]),
+  prizes: t.array(o).nullable().optional()
+  // need to support null values too
+}), a = t.object({
+  transactionState: t.enum(["submitted", "rejected"]).optional(),
+  transactionHash: t.string(),
+  rejectReason: t.string().nullable().optional(),
+  // need to support null values too
+  promotions: t.array(n).nullable().optional()
+  // need to support null values too
+});
+export {
+  a as transactionExecutionResponseSchema,
+  o as transactionPromotionPrizeSchema,
+  n as transactionPromotionSchema
+};

package/dist/swap.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const m=require("./src/features/swap/services/implementation.cjs"),r=require("./src/features/swap/models/order.model.cjs"),e=require("./src/features/swap/models/quote.model.cjs"),a=require("./src/features/swap/models/trade.model.cjs"),o=require("./src/features/swap/utils/totalFee.cjs"),t=require("./src/features/swap/utils/slippage.cjs");exports.SharedSwapService=m.SharedSwapService;exports.SwapOrderRequestSchema=r.SwapOrderRequestSchema;exports.SwapOrderResponseSchema=r.SwapOrderResponseSchema;exports.SwapDataSchema=e.SwapDataSchema;exports.SwapQuoteResponseSchema=e.SwapQuoteResponseSchema;exports.SwapQuoteRouteSchema=e.SwapQuoteRouteSchema;exports.TradeSchema=a.TradeSchema;Object.defineProperty(exports,"TradeType",{enumerable:!0,get:()=>a.TradeType});exports.TradeTypeSchema=a.TradeTypeSchema;exports.calculateTotalFee=o.calculateTotalFee;exports.maximumAmountInForTrade=t.maximumAmountInForTrade;exports.minimumAmountOutFromTrade=t.minimumAmountOutFromTrade;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./src/features/swap/services/SwapSharedService.cjs"),S=require("./src/features/swap/services/SwapTransactionService.cjs"),r=require("./src/features/swap/models/order.model.cjs"),e=require("./src/features/swap/models/quote.model.cjs"),a=require("./src/features/swap/models/trade.model.cjs"),c=require("./src/features/swap/utils/totalFee.cjs"),t=require("./src/features/swap/utils/slippage.cjs");exports.SharedSwapService=o.SharedSwapService;exports.SwapTransactionService=S.SwapTransactionService;exports.SwapOrderRequestSchema=r.SwapOrderRequestSchema;exports.SwapOrderResponseSchema=r.SwapOrderResponseSchema;exports.SwapDataSchema=e.SwapDataSchema;exports.SwapQuoteResponseSchema=e.SwapQuoteResponseSchema;exports.SwapQuoteRouteSchema=e.SwapQuoteRouteSchema;exports.TradeSchema=a.TradeSchema;Object.defineProperty(exports,"TradeType",{enumerable:!0,get:()=>a.TradeType});exports.TradeTypeSchema=a.TradeTypeSchema;exports.calculateTotalFee=c.calculateTotalFee;exports.maximumAmountInForTrade=t.maximumAmountInForTrade;exports.minimumAmountOutFromTrade=t.minimumAmountOutFromTrade;