@0xtorch/evm 0.0.1

package/dist/import/analyzer/seaport/orderFulfilled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orderFulfilled.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/seaport/orderFulfilled.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG7C,eAAO,MAAM,wBAAwB,QAC9B,UAAU,KACd,iBAAiB,GAAG,SAetB,CAAA;AAKD,QAAA,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+FjC,CAAA;AAEF,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAE5E,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG;IAClE,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAA;IAClC,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAA;CACvC,CAAA"}

package/dist/import/analyzer/spam/analyze.d.ts

@@ -0,0 +1,4 @@
+import type { CryptoCurrencyPrice } from '@0xtorch/core';
+import type { AnalyzeParameters, AnalyzeReturnType } from '../types';
+export declare const analyzeAsSpam: <Price extends CryptoCurrencyPrice | undefined>({ chain, transaction, accountAddresses, }: AnalyzeParameters<Price>) => Promise<AnalyzeReturnType<Price> | undefined>;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/import/analyzer/spam/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/spam/analyze.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,mBAAmB,EAGpB,MAAM,eAAe,CAAA;AAMtB,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEpE,eAAO,MAAM,aAAa,uKAuBzB,CAAA"}

package/dist/import/analyzer/spam/index.d.ts

@@ -0,0 +1,2 @@
+export { analyzeAsSpam } from './analyze';
+//# sourceMappingURL=index.d.ts.map

package/dist/import/analyzer/spam/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/spam/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA"}

package/dist/import/analyzer/swap/analyze.d.ts

@@ -0,0 +1,4 @@
+import type { CryptoCurrencyPrice } from '@0xtorch/core';
+import type { AnalyzeParameters, AnalyzeReturnType } from '../types';
+export declare const analyzeSwap: <Price extends CryptoCurrencyPrice | undefined>({ chain, transaction, accountAddresses, }: AnalyzeParameters<Price>) => Promise<AnalyzeReturnType<Price> | undefined>;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/import/analyzer/swap/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/swap/analyze.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,mBAAmB,EAGpB,MAAM,eAAe,CAAA;AAatB,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAYpE,eAAO,MAAM,WAAW,uKAiLvB,CAAA"}

package/dist/import/analyzer/swap/index.d.ts

@@ -0,0 +1,2 @@
+export { analyzeSwap } from './analyze';
+//# sourceMappingURL=index.d.ts.map

package/dist/import/analyzer/swap/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/swap/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA"}

package/dist/import/analyzer/swap/traderJoeLBPairSwap.d.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import type { DecodedLog } from '../../types';
+export declare const parseToTraderJoeLBPairSwap: (log: DecodedLog) => TraderJoeLBPairSwapLog | undefined;
+declare const traderJoeLBPairSwapArgumentsSchema: z.ZodTuple<[z.ZodObject<{
+    indexed: z.ZodLiteral<true>;
+    type: z.ZodLiteral<"address">;
+    value: z.ZodEffects<z.ZodString, `0x${Lowercase<string>}`, string>;
+}, "strip", z.ZodTypeAny, {
+    value: `0x${Lowercase<string>}`;
+    type: "address";
+    indexed: true;
+}, {
+    value: string;
+    type: "address";
+    indexed: true;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<true>;
+    type: z.ZodLiteral<"address">;
+    value: z.ZodEffects<z.ZodString, `0x${Lowercase<string>}`, string>;
+}, "strip", z.ZodTypeAny, {
+    value: `0x${Lowercase<string>}`;
+    type: "address";
+    indexed: true;
+}, {
+    value: string;
+    type: "address";
+    indexed: true;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<true>;
+    type: z.ZodLiteral<"uint256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint256";
+    indexed: true;
+}, {
+    value: bigint;
+    type: "uint256";
+    indexed: true;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"bool">;
+    value: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    value: boolean;
+    type: "bool";
+    indexed: false;
+}, {
+    value: boolean;
+    type: "bool";
+    indexed: false;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"uint256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"uint256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"uint256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"uint256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}>], null>;
+type TraderJoeLBPairSwapArguments = z.infer<typeof traderJoeLBPairSwapArgumentsSchema>;
+export type TraderJoeLBPairSwapLog = Omit<DecodedLog, 'type' | 'args'> & {
+    readonly type: 'TraderJoeLBPairSwapLog';
+    /** [sender, recipient, id, swapForY, amountIn, amountOut, volatilityAccumulated, fees] */
+    readonly args: TraderJoeLBPairSwapArguments;
+};
+export {};
+//# sourceMappingURL=traderJoeLBPairSwap.d.ts.map

package/dist/import/analyzer/swap/traderJoeLBPairSwap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traderJoeLBPairSwap.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/swap/traderJoeLBPairSwap.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG7C,eAAO,MAAM,0BAA0B,QAChC,UAAU,KACd,sBAAsB,GAAG,SAe3B,CAAA;AAKD,QAAA,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAuDtC,CAAA;AACF,KAAK,4BAA4B,GAAG,CAAC,CAAC,KAAK,CACzC,OAAO,kCAAkC,CAC1C,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG;IACvE,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAA;IACvC,0FAA0F;IAC1F,QAAQ,CAAC,IAAI,EAAE,4BAA4B,CAAA;CAC5C,CAAA"}

package/dist/import/analyzer/swap/univ2PairSwap.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import type { DecodedLog } from '../../types';
+export declare const parseToUniv2SwapLog: (log: DecodedLog) => UniV2PairSwapLog | undefined;
+declare const univ2PairSwapArgumentsSchema: z.ZodTuple<[z.ZodObject<{
+    indexed: z.ZodLiteral<true>;
+    type: z.ZodLiteral<"address">;
+    value: z.ZodEffects<z.ZodString, `0x${Lowercase<string>}`, string>;
+}, "strip", z.ZodTypeAny, {
+    value: `0x${Lowercase<string>}`;
+    type: "address";
+    indexed: true;
+}, {
+    value: string;
+    type: "address";
+    indexed: true;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"uint256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"uint256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"uint256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"uint256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<true>;
+    type: z.ZodLiteral<"address">;
+    value: z.ZodEffects<z.ZodString, `0x${Lowercase<string>}`, string>;
+}, "strip", z.ZodTypeAny, {
+    value: `0x${Lowercase<string>}`;
+    type: "address";
+    indexed: true;
+}, {
+    value: string;
+    type: "address";
+    indexed: true;
+}>], null>;
+type Univ2PairSwapArguments = z.infer<typeof univ2PairSwapArgumentsSchema>;
+export type UniV2PairSwapLog = Omit<DecodedLog, 'type' | 'args'> & {
+    readonly type: 'UniV2PairSwapLog';
+    /** [sender, amount0In, amount1In, amount0Out, amount1Out, to] */
+    readonly args: Univ2PairSwapArguments;
+};
+export {};
+//# sourceMappingURL=univ2PairSwap.d.ts.map

package/dist/import/analyzer/swap/univ2PairSwap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"univ2PairSwap.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/swap/univ2PairSwap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG7C,eAAO,MAAM,mBAAmB,QACzB,UAAU,KACd,gBAAgB,GAAG,SAerB,CAAA;AAKD,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2ChC,CAAA;AACF,KAAK,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAE1E,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG;IACjE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAA;IACjC,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAA;CACtC,CAAA"}

package/dist/import/analyzer/swap/univ3PoolSwap.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import type { DecodedLog } from '../../types';
+export declare const parseToUniv3SwapLog: (log: DecodedLog) => UniV3PoolSwapLog | undefined;
+declare const univ3PoolSwapArgumentsSchema: z.ZodTuple<[z.ZodObject<{
+    indexed: z.ZodLiteral<true>;
+    type: z.ZodLiteral<"address">;
+    value: z.ZodEffects<z.ZodString, `0x${Lowercase<string>}`, string>;
+}, "strip", z.ZodTypeAny, {
+    value: `0x${Lowercase<string>}`;
+    type: "address";
+    indexed: true;
+}, {
+    value: string;
+    type: "address";
+    indexed: true;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<true>;
+    type: z.ZodLiteral<"address">;
+    value: z.ZodEffects<z.ZodString, `0x${Lowercase<string>}`, string>;
+}, "strip", z.ZodTypeAny, {
+    value: `0x${Lowercase<string>}`;
+    type: "address";
+    indexed: true;
+}, {
+    value: string;
+    type: "address";
+    indexed: true;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"int256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "int256";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "int256";
+    indexed: false;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"int256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "int256";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "int256";
+    indexed: false;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"uint160">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint160";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "uint160";
+    indexed: false;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"uint128">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint128";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "uint128";
+    indexed: false;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"int24">;
+    value: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    value: number;
+    type: "int24";
+    indexed: false;
+}, {
+    value: number;
+    type: "int24";
+    indexed: false;
+}>], null>;
+type UniV3PoolSwapArguments = z.infer<typeof univ3PoolSwapArgumentsSchema>;
+export type UniV3PoolSwapLog = Omit<DecodedLog, 'type' | 'args'> & {
+    readonly type: 'UniV3PoolSwapLog';
+    /** [sender, recipient, amount0, amount1, sqrtPriceX96, liquidity, tick] */
+    readonly args: UniV3PoolSwapArguments;
+};
+export {};
+//# sourceMappingURL=univ3PoolSwap.d.ts.map

package/dist/import/analyzer/swap/univ3PoolSwap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"univ3PoolSwap.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/swap/univ3PoolSwap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG7C,eAAO,MAAM,mBAAmB,QACzB,UAAU,KACd,gBAAgB,GAAG,SAerB,CAAA;AAKD,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAiDhC,CAAA;AACF,KAAK,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAE1E,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG;IACjE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAA;IACjC,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAA;CACtC,CAAA"}

package/dist/import/analyzer/swap/wrappedDeposit.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { DecodedLog } from '../../types';
+export declare const parseToWrappedDepositLog: (log: DecodedLog) => WrappedDepositLog | undefined;
+declare const wrappedDepositArgumentsSchema: z.ZodTuple<[z.ZodObject<{
+    indexed: z.ZodLiteral<true>;
+    type: z.ZodLiteral<"address">;
+    value: z.ZodEffects<z.ZodString, `0x${Lowercase<string>}`, string>;
+}, "strip", z.ZodTypeAny, {
+    value: `0x${Lowercase<string>}`;
+    type: "address";
+    indexed: true;
+}, {
+    value: string;
+    type: "address";
+    indexed: true;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"uint256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}>], null>;
+type WrappedDepositArguments = z.infer<typeof wrappedDepositArgumentsSchema>;
+export type WrappedDepositLog = Omit<DecodedLog, 'type' | 'args'> & {
+    readonly type: 'WrappedDepositLog';
+    /** [dst, wad] */
+    readonly args: WrappedDepositArguments;
+};
+export {};
+//# sourceMappingURL=wrappedDeposit.d.ts.map

package/dist/import/analyzer/swap/wrappedDeposit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrappedDeposit.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/swap/wrappedDeposit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG7C,eAAO,MAAM,wBAAwB,QAC9B,UAAU,KACd,iBAAiB,GAAG,SAetB,CAAA;AAKD,QAAA,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;UAgBjC,CAAA;AAEF,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAE5E,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG;IAClE,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAA;IAClC,iBAAiB;IACjB,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAA;CACvC,CAAA"}

package/dist/import/analyzer/swap/wrappedWithdrawal.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { DecodedLog } from '../../types';
+export declare const parseToWrappedWithdrawalLog: (log: DecodedLog) => WrappedWithdrawalLog | undefined;
+declare const wrappedWithdrawalArgumentsSchema: z.ZodTuple<[z.ZodObject<{
+    indexed: z.ZodLiteral<true>;
+    type: z.ZodLiteral<"address">;
+    value: z.ZodEffects<z.ZodString, `0x${Lowercase<string>}`, string>;
+}, "strip", z.ZodTypeAny, {
+    value: `0x${Lowercase<string>}`;
+    type: "address";
+    indexed: true;
+}, {
+    value: string;
+    type: "address";
+    indexed: true;
+}>, z.ZodObject<{
+    indexed: z.ZodLiteral<false>;
+    type: z.ZodLiteral<"uint256">;
+    value: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}, {
+    value: bigint;
+    type: "uint256";
+    indexed: false;
+}>], null>;
+type WrappedWithdrawalArguments = z.infer<typeof wrappedWithdrawalArgumentsSchema>;
+export type WrappedWithdrawalLog = Omit<DecodedLog, 'type' | 'args'> & {
+    readonly type: 'WrappedWithdrawalLog';
+    /** [src, wad] */
+    readonly args: WrappedWithdrawalArguments;
+};
+export {};
+//# sourceMappingURL=wrappedWithdrawal.d.ts.map

package/dist/import/analyzer/swap/wrappedWithdrawal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrappedWithdrawal.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/swap/wrappedWithdrawal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG7C,eAAO,MAAM,2BAA2B,QACjC,UAAU,KACd,oBAAoB,GAAG,SAezB,CAAA;AAKD,QAAA,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;UAgBpC,CAAA;AAEF,KAAK,0BAA0B,GAAG,CAAC,CAAC,KAAK,CACvC,OAAO,gCAAgC,CACxC,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG;IACrE,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAA;IACrC,iBAAiB;IACjB,QAAQ,CAAC,IAAI,EAAE,0BAA0B,CAAA;CAC1C,CAAA"}

package/dist/import/analyzer/transfer/analyze.d.ts

@@ -0,0 +1,4 @@
+import type { CryptoCurrencyPrice } from '@0xtorch/core';
+import type { AnalyzeParameters, AnalyzeReturnType } from '../types';
+export declare const analyzeTransfer: <Price extends CryptoCurrencyPrice | undefined>({ chain, transaction, accountAddresses, }: AnalyzeParameters<Price>) => Promise<AnalyzeReturnType<Price> | undefined>;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/import/analyzer/transfer/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/transfer/analyze.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAwB,MAAM,eAAe,CAAA;AAM9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEpE,eAAO,MAAM,eAAe,uKAuB3B,CAAA"}

package/dist/import/analyzer/transfer/index.d.ts

@@ -0,0 +1,2 @@
+export { analyzeTransfer } from './analyze';
+//# sourceMappingURL=index.d.ts.map

package/dist/import/analyzer/transfer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/analyzer/transfer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA"}

package/dist/import/analyzer/types.d.ts

@@ -0,0 +1,17 @@
+import type { AccountAction, AccountActionType, ActionType, Config, CryptoCurrencyPrice, NormalAction } from '@0xtorch/core';
+import type { Chain } from '../chains';
+import type { EvmAccount, LowerHex, TransactionDecoded, TransactionSource } from '../types';
+export type Analyzer<Price extends CryptoCurrencyPrice | undefined> = {
+    readonly analyze: Analyze<Price>;
+};
+export type Analyze<Price extends CryptoCurrencyPrice | undefined> = (parameters: AnalyzeParameters<Price>, config?: Config) => Promise<AnalyzeReturnType<Price>>;
+export type AnalyzeParameters<Price extends CryptoCurrencyPrice | undefined> = {
+    readonly chain: Chain;
+    readonly transaction: TransactionDecoded<Price>;
+    readonly accountAddresses: readonly LowerHex[];
+};
+export type AnalyzeReturnType<Price extends CryptoCurrencyPrice | undefined> = {
+    readonly actions: readonly NormalAction<ActionType, EvmAccount | undefined, Price>[];
+    readonly accountActions: readonly AccountAction<AccountActionType, TransactionSource, EvmAccount | undefined, Price>[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/import/analyzer/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/analyzer/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,MAAM,EACN,mBAAmB,EACnB,YAAY,EACb,MAAM,eAAe,CAAA;AACtB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,KAAK,EACV,UAAU,EACV,QAAQ,EACR,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,UAAU,CAAA;AAEjB,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,mBAAmB,GAAG,SAAS,IAAI;IACpE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,OAAO,CAAC,KAAK,SAAS,mBAAmB,GAAG,SAAS,IAAI,CACnE,UAAU,EAAE,iBAAiB,CAAC,KAAK,CAAC,EACpC,MAAM,CAAC,EAAE,MAAM,KACZ,OAAO,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAA;AAEtC,MAAM,MAAM,iBAAiB,CAAC,KAAK,SAAS,mBAAmB,GAAG,SAAS,IAAI;IAC7E,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAA;IAC/C,QAAQ,CAAC,gBAAgB,EAAE,SAAS,QAAQ,EAAE,CAAA;CAC/C,CAAA;AAED,MAAM,MAAM,iBAAiB,CAAC,KAAK,SAAS,mBAAmB,GAAG,SAAS,IAAI;IAC7E,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,CACrC,UAAU,EACV,UAAU,GAAG,SAAS,EACtB,KAAK,CACN,EAAE,CAAA;IACH,QAAQ,CAAC,cAAc,EAAE,SAAS,aAAa,CAC7C,iBAAiB,EACjB,iBAAiB,EACjB,UAAU,GAAG,SAAS,EACtB,KAAK,CACN,EAAE,CAAA;CACJ,CAAA"}

package/dist/import/apps/index.d.ts

@@ -0,0 +1,2 @@
+export type { AppDataSource } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/import/apps/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/apps/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA"}

package/dist/import/apps/types.d.ts

@@ -0,0 +1,6 @@
+import type { App, Config } from '@0xtorch/core';
+import type { LowerHex } from '../types';
+export type AppDataSource = {
+    getApp: (chainId: number, address: LowerHex, config?: Config) => Promise<App | undefined>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/import/apps/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/apps/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,CACN,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,QAAQ,EACjB,MAAM,CAAC,EAAE,MAAM,KACZ,OAAO,CAAC,GAAG,GAAG,SAAS,CAAC,CAAA;CAC9B,CAAA"}

package/dist/import/chains/definitions/arbitrumOne.d.ts

@@ -0,0 +1,99 @@
+import type { Client } from '../../clients';
+import type { Explorer } from '../../explorers';
+import type { Chain } from '../types';
+export declare const createArbitrumOneChain: (arbiscanApiKey: string) => Chain;
+type CreateArbitrumOneChainParameters<TClient extends Client, TExplorer extends Explorer> = {
+    readonly client: TClient;
+    readonly explorer: TExplorer;
+};
+export declare const createArbitrumOneChainCustom: <const TClient extends Client, const TExplorer extends Explorer>({ client, explorer, }: CreateArbitrumOneChainParameters<TClient, TExplorer>) => {
+    readonly id: 42161;
+    readonly network: "arbitrum-one";
+    readonly name: "Arbitrum One";
+    readonly nativeToken: {
+        readonly name: "Ethereum";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+        readonly currency: {
+            readonly type: "CryptoCurrency";
+            readonly id: "ethereum";
+            readonly name: "Ethereum";
+            readonly symbol: "ETH";
+            readonly icon: undefined;
+            readonly market: {
+                readonly coingeckoId: "ethereum";
+                readonly marketCapUsd: undefined;
+            };
+            readonly updatedAt: number;
+        };
+    };
+    readonly explorer: TExplorer;
+    readonly client: TClient;
+    readonly blockTime: 250;
+    readonly coingeckoId: "arbitrum-one";
+    readonly defillamaId: "arbitrum";
+};
+export declare const arbitrumOneHttpRpcs: readonly [{
+    readonly url: "https://arbitrum.llamarpc.com";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 80000n;
+}, {
+    readonly url: "https://arb1.arbitrum.io/rpc";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 160000n;
+}, {
+    readonly url: "https://rpc.ankr.com/arbitrum";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 3000n;
+}, {
+    readonly url: "https://1rpc.io/arb";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 10000n;
+}, {
+    readonly url: "https://arb-pokt.nodies.app";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 80000n;
+}, {
+    readonly url: "https://arbitrum.blockpi.network/v1/rpc/public";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 1024n;
+}, {
+    readonly url: "https://endpoints.omniatech.io/v1/arbitrum/one/public";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 3000n;
+}, {
+    readonly url: "https://arb-mainnet-public.unifra.io";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 10000n;
+}, {
+    readonly url: "https://arbitrum.api.onfinality.io/public";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 2000n;
+}, {
+    readonly url: "https://rpc.arb1.arbitrum.gateway.fm";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 10000n;
+}, {
+    readonly url: "https://arbitrum-one.publicnode.com";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 40000n;
+}, {
+    readonly url: "https://arbitrum.meowrpc.com";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 40000n;
+}];
+export declare const arbitrumOneWebsocketRpcUrls: readonly ["wss://arbitrum-one.publicnode.com"];
+export {};
+//# sourceMappingURL=arbitrumOne.d.ts.map

package/dist/import/chains/definitions/arbitrumOne.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arbitrumOne.d.ts","sourceRoot":"","sources":["../../../../src/chains/definitions/arbitrumOne.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAE3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE/C,OAAO,KAAK,EAAE,KAAK,EAAW,MAAM,UAAU,CAAA;AAG9C,eAAO,MAAM,sBAAsB,mBAAoB,MAAM,KAAG,KAY5D,CAAA;AAEJ,KAAK,gCAAgC,CACnC,OAAO,SAAS,MAAM,EACtB,SAAS,SAAS,QAAQ,IACxB;IACF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAA;CAC7B,CAAA;AAED,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBrC,CAAA;AAEJ,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyEO,CAAA;AAEvC,eAAO,MAAM,2BAA2B,gDAE9B,CAAA"}

package/dist/import/chains/definitions/astar.d.ts

@@ -0,0 +1,64 @@
+import type { Client } from '../../clients';
+import type { Explorer } from '../../explorers';
+import type { Chain } from '../types';
+type CreateAstarChainParameters<TClient extends Client, TExplorer extends Explorer> = {
+    readonly client: TClient;
+    readonly explorer: TExplorer;
+};
+export declare const createAstarChain: () => Chain;
+export declare const createAstarChainCustom: <const TClient extends Client, const TExplorer extends Explorer>({ client, explorer, }: CreateAstarChainParameters<TClient, TExplorer>) => {
+    readonly id: 592;
+    readonly network: "astar-evm";
+    readonly name: "Astar (EVM)";
+    readonly nativeToken: {
+        readonly name: "Astar";
+        readonly symbol: "ASTR";
+        readonly decimals: 18;
+        readonly currency: {
+            readonly type: "CryptoCurrency";
+            readonly id: "astar";
+            readonly name: "Astar";
+            readonly symbol: "ASTR";
+            readonly icon: undefined;
+            readonly market: {
+                readonly coingeckoId: "astar";
+                readonly marketCapUsd: undefined;
+            };
+            readonly updatedAt: number;
+        };
+    };
+    readonly explorer: TExplorer;
+    readonly client: TClient;
+    readonly blockTime: 12000;
+    readonly coingeckoId: "astar";
+    readonly defillamaId: "astar";
+};
+export declare const astarHttpRpcs: readonly [{
+    readonly url: "https://evm.astar.network/";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 20000n;
+}, {
+    readonly url: "https://astar.public.blastapi.io";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: false;
+    readonly getLogsMaxBlockRange: 0n;
+}, {
+    readonly url: "https://astar.api.onfinality.io/public";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: false;
+    readonly getLogsMaxBlockRange: 0n;
+}, {
+    readonly url: "https://astar-rpc.dwellir.com";
+    readonly isArchive: true;
+    readonly getLogsIsUsable: true;
+    readonly getLogsMaxBlockRange: 10000n;
+}, {
+    readonly url: "https://1rpc.io/astr";
+    readonly isArchive: false;
+    readonly getLogsIsUsable: false;
+    readonly getLogsMaxBlockRange: 0n;
+}];
+export declare const astarWebsocketRpcUrls: readonly ["wss://rpc.astar.network", "wss://astar.public.blastapi.io", "wss://astar.api.onfinality.io/public-ws", "wss://astar-rpc.dwellir.com"];
+export {};
+//# sourceMappingURL=astar.d.ts.map

package/dist/import/chains/definitions/astar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astar.d.ts","sourceRoot":"","sources":["../../../../src/chains/definitions/astar.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAE3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE/C,OAAO,KAAK,EAAE,KAAK,EAAW,MAAM,UAAU,CAAA;AAG9C,KAAK,0BAA0B,CAC7B,OAAO,SAAS,MAAM,EACtB,SAAS,SAAS,QAAQ,IACxB;IACF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAA;CAC7B,CAAA;AAED,eAAO,MAAM,gBAAgB,QAAO,KAWhC,CAAA;AAEJ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;CAsB/B,CAAA;AAEJ,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;EA+Ba,CAAA;AAEvC,eAAO,MAAM,qBAAqB,kJAKxB,CAAA"}