@the-situation/utils 0.5.0-alpha.0

package/dist/abi-encode.d.ts

@@ -0,0 +1,185 @@
+/**
+ * ABI-aware encoding utilities for Starknet calldata.
+ *
+ * This module provides utilities that convert SDK types to the format expected
+ * by starknet.js CallData.compile() with ABI awareness and supports single-type
+ * encode/decode via parseCalldataField.
+ *
+ * Using ABI-aware encoding avoids the zero-dropping serialization bug that
+ * occurs with manual array flattening.
+ *
+ * ## Why ABI-Aware Encoding?
+ *
+ * The starknet.js library has a serialization bug that can drop zero values (0n)
+ * at certain positions when using manual array flattening. By using CallData.compile()
+ * with method names and structured objects, starknet.js correctly handles the
+ * serialization through ABI resolution.
+ *
+ * @module
+ */
+import { type Abi } from 'starknet';
+import type { NormalDistributionRaw, NormalSqrtHintsRaw, SQ128x128Raw } from '@the-situation/core';
+/**
+ * SQ128x128 in ABI format with snake_case field names.
+ *
+ * Field names must match the Cairo struct exactly:
+ * - limb0, limb1, limb2, limb3 (magnitude limbs)
+ * - neg (sign flag)
+ */
+export interface AbiSQ128x128 {
+    readonly limb0: bigint;
+    readonly limb1: bigint;
+    readonly limb2: bigint;
+    readonly limb3: bigint;
+    readonly neg: boolean;
+}
+/**
+ * Normal distribution in ABI format.
+ */
+export interface AbiNormalDistribution {
+    readonly mean: AbiSQ128x128;
+    readonly variance: AbiSQ128x128;
+    readonly sigma: AbiSQ128x128;
+}
+/**
+ * Hints in ABI format with snake_case field names.
+ */
+export interface AbiNormalSqrtHints {
+    readonly l2_norm_denom: AbiSQ128x128;
+    readonly backing_denom: AbiSQ128x128;
+}
+/**
+ * Converts SDK SQ128x128Raw type to ABI format.
+ *
+ * The SDK type and ABI type have the same field names, but this function
+ * provides a clear conversion point and type safety.
+ *
+ * @param raw - SDK SQ128x128Raw value
+ * @returns ABI-compatible SQ128x128
+ */
+export declare function toAbiSQ128x128(raw: SQ128x128Raw): AbiSQ128x128;
+/**
+ * Converts SDK NormalDistributionRaw to ABI format.
+ *
+ * @param raw - SDK distribution value
+ * @returns ABI-compatible distribution
+ */
+export declare function toAbiDistribution(raw: NormalDistributionRaw): AbiNormalDistribution;
+/**
+ * Converts SDK hints to ABI format with snake_case field names.
+ *
+ * Cairo uses snake_case for struct field names:
+ * - l2_norm_denom
+ * - backing_denom
+ *
+ * @param hints - SDK hints in ABI shape
+ * @returns ABI-compatible hints with snake_case field names
+ */
+export declare function toAbiHints(hints: NormalSqrtHintsRaw): AbiNormalSqrtHints;
+/**
+ * Encodes a single ABI type using starknet.js parseCalldataField.
+ *
+ * This is useful when you need type-level encoding without a function context.
+ */
+export declare function encodeAbiType<T>(abi: Abi, typeName: string, value: T): string[];
+/**
+ * Decodes a single ABI type using a synthetic ABI function.
+ *
+ * @param abi - Contract ABI that defines the type
+ * @param typeName - Fully-qualified ABI type name
+ * @param calldata - Encoded calldata for the type
+ */
+export declare function decodeAbiType<T>(abi: Abi, typeName: string, calldata: readonly (string | bigint)[]): T;
+/**
+ * Encodes SQ128x128Raw using ABI type metadata.
+ */
+export declare function encodeSQ128x128RawType(abi: Abi, value: SQ128x128Raw): string[];
+/**
+ * Decodes SQ128x128Raw using ABI type metadata.
+ */
+export declare function decodeSQ128x128RawType(abi: Abi, calldata: readonly (string | bigint)[]): SQ128x128Raw;
+/**
+ * Encodes NormalDistributionRaw using ABI type metadata.
+ */
+export declare function encodeNormalDistributionRawType(abi: Abi, value: NormalDistributionRaw): string[];
+/**
+ * Decodes NormalDistributionRaw using ABI type metadata.
+ */
+export declare function decodeNormalDistributionRawType(abi: Abi, calldata: readonly (string | bigint)[]): NormalDistributionRaw;
+/**
+ * Encodes NormalSqrtHintsRaw using ABI type metadata.
+ */
+export declare function encodeNormalSqrtHintsRawType(abi: Abi, value: NormalSqrtHintsRaw): string[];
+/**
+ * Decodes NormalSqrtHintsRaw using ABI type metadata.
+ */
+export declare function decodeNormalSqrtHintsRawType(abi: Abi, calldata: readonly (string | bigint)[]): NormalSqrtHintsRaw;
+/**
+ * Encoder class for trade calldata using ABI-aware encoding.
+ *
+ * This class wraps starknet.js CallData with the AMM contract ABI to provide
+ * proper struct encoding for trade operations.
+ *
+ * @example
+ * ```typescript
+ * const encoder = new TradeCalldataEncoder(ammAbi);
+ * const calldata = encoder.encodeExecuteTrade(
+ *   { mean: ..., variance: ..., sigma: ... },
+ *   xStar,
+ *   collateral,
+ *   { l2_norm_denom: ..., backing_denom: ... }
+ * );
+ * ```
+ */
+export declare class TradeCalldataEncoder {
+    private readonly callData;
+    constructor(abi: Abi);
+    /**
+     * Encodes execute_trade calldata using ABI-aware encoding.
+     *
+     * The execute_trade function signature is:
+     * ```cairo
+     * fn execute_trade(
+     *   ref self: ContractState,
+     *   candidate: NormalDistribution,
+     *   x_star: SQ128x128,
+     *   supplied_collateral: SQ128x128,
+     *   candidate_hints: NormalSqrtHints,
+     * ) -> TradeExecution
+     * ```
+     *
+     * @param candidate - The candidate distribution (mean, variance, sigma)
+     * @param xStar - The x* value for collateral computation
+     * @param suppliedCollateral - The collateral to supply
+     * @param hints - Precomputed hints for the candidate distribution
+     * @returns Encoded calldata as string array
+     */
+    encodeExecuteTrade(candidate: NormalDistributionRaw, xStar: SQ128x128Raw, suppliedCollateral: SQ128x128Raw, hints: NormalSqrtHintsRaw): string[];
+    /**
+     * Encodes close_position calldata using ABI-aware encoding.
+     *
+     * The close_position function signature is:
+     * ```cairo
+     * fn close_position(
+     *   ref self: ContractState,
+     *   x_star: SQ128x128,
+     *   additional_collateral: SQ128x128,
+     *   target_hints: NormalSqrtHints,
+     * ) -> PositionCloseResult
+     * ```
+     *
+     * @param xStar - The x* value for collateral computation
+     * @param additionalCollateral - Additional collateral to supply
+     * @param targetHints - Hints for the target (flat) distribution
+     * @returns Encoded calldata as string array
+     */
+    encodeClosePosition(xStar: SQ128x128Raw, additionalCollateral: SQ128x128Raw, targetHints: NormalSqrtHintsRaw): string[];
+}
+/**
+ * Creates a TradeCalldataEncoder for the given ABI.
+ *
+ * @param abi - The AMM contract ABI
+ * @returns A new TradeCalldataEncoder instance
+ */
+export declare function createTradeEncoder(abi: Abi): TradeCalldataEncoder;
+//# sourceMappingURL=abi-encode.d.ts.map

package/dist/abi-encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi-encode.d.ts","sourceRoot":"","sources":["../src/abi-encode.ts"],"names":[],"mappings":"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"}

package/dist/abi-encode.js

@@ -0,0 +1,278 @@
+/**
+ * ABI-aware encoding utilities for Starknet calldata.
+ *
+ * This module provides utilities that convert SDK types to the format expected
+ * by starknet.js CallData.compile() with ABI awareness and supports single-type
+ * encode/decode via parseCalldataField.
+ *
+ * Using ABI-aware encoding avoids the zero-dropping serialization bug that
+ * occurs with manual array flattening.
+ *
+ * ## Why ABI-Aware Encoding?
+ *
+ * The starknet.js library has a serialization bug that can drop zero values (0n)
+ * at certain positions when using manual array flattening. By using CallData.compile()
+ * with method names and structured objects, starknet.js correctly handles the
+ * serialization through ABI resolution.
+ *
+ * @module
+ */
+import { CallData, createAbiParser, hdParsingStrategy, parseCalldataField, } from 'starknet';
+/**
+ * Converts SDK SQ128x128Raw type to ABI format.
+ *
+ * The SDK type and ABI type have the same field names, but this function
+ * provides a clear conversion point and type safety.
+ *
+ * @param raw - SDK SQ128x128Raw value
+ * @returns ABI-compatible SQ128x128
+ */
+export function toAbiSQ128x128(raw) {
+    return {
+        limb0: raw.limb0,
+        limb1: raw.limb1,
+        limb2: raw.limb2,
+        limb3: raw.limb3,
+        neg: raw.neg,
+    };
+}
+/**
+ * Converts SDK NormalDistributionRaw to ABI format.
+ *
+ * @param raw - SDK distribution value
+ * @returns ABI-compatible distribution
+ */
+export function toAbiDistribution(raw) {
+    return {
+        mean: toAbiSQ128x128(raw.mean),
+        variance: toAbiSQ128x128(raw.variance),
+        sigma: toAbiSQ128x128(raw.sigma),
+    };
+}
+/**
+ * Converts SDK hints to ABI format with snake_case field names.
+ *
+ * Cairo uses snake_case for struct field names:
+ * - l2_norm_denom
+ * - backing_denom
+ *
+ * @param hints - SDK hints in ABI shape
+ * @returns ABI-compatible hints with snake_case field names
+ */
+export function toAbiHints(hints) {
+    return {
+        // biome-ignore lint/style/useNamingConvention: Cairo uses snake_case
+        l2_norm_denom: toAbiSQ128x128(hints.l2_norm_denom),
+        // biome-ignore lint/style/useNamingConvention: Cairo uses snake_case
+        backing_denom: toAbiSQ128x128(hints.backing_denom),
+    };
+}
+// ============================================================================
+// Type Codec (ABI-aware single-type encode/decode)
+// ============================================================================
+const SQ128X128_RAW_ABI_TYPE = 'the_situation::types::sq128::types::SQ128x128Raw';
+const NORMAL_DISTRIBUTION_RAW_ABI_TYPE = 'the_situation::types::normal_distribution::NormalDistributionRaw';
+const NORMAL_SQRT_HINTS_RAW_ABI_TYPE = 'the_situation::onchain::common::NormalSqrtHintsRaw';
+function findAbiTypeEntry(abi, typeName) {
+    const entry = abi.find((abiItem) => {
+        if (!abiItem || typeof abiItem !== 'object') {
+            return false;
+        }
+        const item = abiItem;
+        return item.name === typeName && (item.type === 'struct' || item.type === 'enum');
+    });
+    if (!entry) {
+        throw new Error(`ABI type not found: ${typeName}`);
+    }
+    return entry;
+}
+function getDecodeFunctionName(abi) {
+    const baseName = '__type_decode__';
+    let name = baseName;
+    let suffix = 0;
+    while (abi.some((abiItem) => {
+        if (!abiItem || typeof abiItem !== 'object') {
+            return false;
+        }
+        const item = abiItem;
+        return item.name === name;
+    })) {
+        suffix += 1;
+        name = `${baseName}${suffix}`;
+    }
+    return name;
+}
+/**
+ * Encodes a single ABI type using starknet.js parseCalldataField.
+ *
+ * This is useful when you need type-level encoding without a function context.
+ */
+export function encodeAbiType(abi, typeName, value) {
+    const typeEntry = findAbiTypeEntry(abi, typeName);
+    const structs = CallData.getAbiStruct(abi);
+    const enums = CallData.getAbiEnum(abi);
+    const parser = createAbiParser(abi, hdParsingStrategy);
+    const argsIterator = [value][Symbol.iterator]();
+    const inputAbi = { name: typeEntry.type, type: typeEntry.name };
+    const encoded = parseCalldataField({
+        argsIterator,
+        input: inputAbi,
+        structs,
+        enums,
+        parser,
+    });
+    return Array.isArray(encoded) ? encoded : [encoded];
+}
+/**
+ * Decodes a single ABI type using a synthetic ABI function.
+ *
+ * @param abi - Contract ABI that defines the type
+ * @param typeName - Fully-qualified ABI type name
+ * @param calldata - Encoded calldata for the type
+ */
+export function decodeAbiType(abi, typeName, calldata) {
+    const typeEntry = findAbiTypeEntry(abi, typeName);
+    const methodName = getDecodeFunctionName(abi);
+    const decodeAbi = [
+        ...abi,
+        {
+            type: 'function',
+            name: methodName,
+            inputs: [],
+            outputs: [{ name: 'value', type: typeEntry.name }],
+            state_mutability: 'view',
+        },
+    ];
+    const callData = new CallData(decodeAbi, hdParsingStrategy);
+    const response = calldata.map((value) => value.toString());
+    const parsed = callData.parse(methodName, response);
+    return parsed.value;
+}
+/**
+ * Encodes SQ128x128Raw using ABI type metadata.
+ */
+export function encodeSQ128x128RawType(abi, value) {
+    return encodeAbiType(abi, SQ128X128_RAW_ABI_TYPE, value);
+}
+/**
+ * Decodes SQ128x128Raw using ABI type metadata.
+ */
+export function decodeSQ128x128RawType(abi, calldata) {
+    return decodeAbiType(abi, SQ128X128_RAW_ABI_TYPE, calldata);
+}
+/**
+ * Encodes NormalDistributionRaw using ABI type metadata.
+ */
+export function encodeNormalDistributionRawType(abi, value) {
+    return encodeAbiType(abi, NORMAL_DISTRIBUTION_RAW_ABI_TYPE, value);
+}
+/**
+ * Decodes NormalDistributionRaw using ABI type metadata.
+ */
+export function decodeNormalDistributionRawType(abi, calldata) {
+    return decodeAbiType(abi, NORMAL_DISTRIBUTION_RAW_ABI_TYPE, calldata);
+}
+/**
+ * Encodes NormalSqrtHintsRaw using ABI type metadata.
+ */
+export function encodeNormalSqrtHintsRawType(abi, value) {
+    return encodeAbiType(abi, NORMAL_SQRT_HINTS_RAW_ABI_TYPE, value);
+}
+/**
+ * Decodes NormalSqrtHintsRaw using ABI type metadata.
+ */
+export function decodeNormalSqrtHintsRawType(abi, calldata) {
+    return decodeAbiType(abi, NORMAL_SQRT_HINTS_RAW_ABI_TYPE, calldata);
+}
+/**
+ * Encoder class for trade calldata using ABI-aware encoding.
+ *
+ * This class wraps starknet.js CallData with the AMM contract ABI to provide
+ * proper struct encoding for trade operations.
+ *
+ * @example
+ * ```typescript
+ * const encoder = new TradeCalldataEncoder(ammAbi);
+ * const calldata = encoder.encodeExecuteTrade(
+ *   { mean: ..., variance: ..., sigma: ... },
+ *   xStar,
+ *   collateral,
+ *   { l2_norm_denom: ..., backing_denom: ... }
+ * );
+ * ```
+ */
+export class TradeCalldataEncoder {
+    callData;
+    constructor(abi) {
+        this.callData = new CallData(abi);
+    }
+    /**
+     * Encodes execute_trade calldata using ABI-aware encoding.
+     *
+     * The execute_trade function signature is:
+     * ```cairo
+     * fn execute_trade(
+     *   ref self: ContractState,
+     *   candidate: NormalDistribution,
+     *   x_star: SQ128x128,
+     *   supplied_collateral: SQ128x128,
+     *   candidate_hints: NormalSqrtHints,
+     * ) -> TradeExecution
+     * ```
+     *
+     * @param candidate - The candidate distribution (mean, variance, sigma)
+     * @param xStar - The x* value for collateral computation
+     * @param suppliedCollateral - The collateral to supply
+     * @param hints - Precomputed hints for the candidate distribution
+     * @returns Encoded calldata as string array
+     */
+    encodeExecuteTrade(candidate, xStar, suppliedCollateral, hints) {
+        return this.callData.compile('execute_trade', {
+            candidate: toAbiDistribution(candidate),
+            // biome-ignore lint/style/useNamingConvention: Cairo uses snake_case
+            x_star: toAbiSQ128x128(xStar),
+            // biome-ignore lint/style/useNamingConvention: Cairo uses snake_case
+            supplied_collateral: toAbiSQ128x128(suppliedCollateral),
+            // biome-ignore lint/style/useNamingConvention: Cairo uses snake_case
+            candidate_hints: toAbiHints(hints),
+        });
+    }
+    /**
+     * Encodes close_position calldata using ABI-aware encoding.
+     *
+     * The close_position function signature is:
+     * ```cairo
+     * fn close_position(
+     *   ref self: ContractState,
+     *   x_star: SQ128x128,
+     *   additional_collateral: SQ128x128,
+     *   target_hints: NormalSqrtHints,
+     * ) -> PositionCloseResult
+     * ```
+     *
+     * @param xStar - The x* value for collateral computation
+     * @param additionalCollateral - Additional collateral to supply
+     * @param targetHints - Hints for the target (flat) distribution
+     * @returns Encoded calldata as string array
+     */
+    encodeClosePosition(xStar, additionalCollateral, targetHints) {
+        return this.callData.compile('close_position', {
+            // biome-ignore lint/style/useNamingConvention: Cairo uses snake_case
+            x_star: toAbiSQ128x128(xStar),
+            // biome-ignore lint/style/useNamingConvention: Cairo uses snake_case
+            additional_collateral: toAbiSQ128x128(additionalCollateral),
+            // biome-ignore lint/style/useNamingConvention: Cairo uses snake_case
+            target_hints: toAbiHints(targetHints),
+        });
+    }
+}
+/**
+ * Creates a TradeCalldataEncoder for the given ABI.
+ *
+ * @param abi - The AMM contract ABI
+ * @returns A new TradeCalldataEncoder instance
+ */
+export function createTradeEncoder(abi) {
+    return new TradeCalldataEncoder(abi);
+}
+//# sourceMappingURL=abi-encode.js.map

package/dist/abi-encode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi-encode.js","sourceRoot":"","sources":["../src/abi-encode.ts"],"names":[],"mappings":"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"}

package/dist/address.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Address formatting utilities.
+ *
+ * Ensures consistent hex format for all Starknet addresses.
+ *
+ * @module
+ */
+/**
+ * Converts any address format to hex string.
+ *
+ * Handles:
+ * - Hex strings (0x...) - returned as-is
+ * - Decimal strings - converted to hex
+ * - BigInt values - converted to hex
+ *
+ * @param address - Address in any format
+ * @returns Address as hex string (0x prefixed)
+ *
+ * @example
+ * ```typescript
+ * toHexAddress('0x049d36570d4e46f48e99674bd3fcc84644ddd6b9')
+ * // => '0x049d36570d4e46f48e99674bd3fcc84644ddd6b9'
+ *
+ * toHexAddress('2009894490435840142178903814830')
+ * // => '0x049d36570d4e46f48e99674bd3fcc84644ddd6b9'
+ * ```
+ */
+export declare function toHexAddress(address: string | bigint): string;
+//# sourceMappingURL=address.d.ts.map

package/dist/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../src/address.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAQ7D"}

package/dist/address.js

@@ -0,0 +1,38 @@
+/**
+ * Address formatting utilities.
+ *
+ * Ensures consistent hex format for all Starknet addresses.
+ *
+ * @module
+ */
+import { num } from 'starknet';
+/**
+ * Converts any address format to hex string.
+ *
+ * Handles:
+ * - Hex strings (0x...) - returned as-is
+ * - Decimal strings - converted to hex
+ * - BigInt values - converted to hex
+ *
+ * @param address - Address in any format
+ * @returns Address as hex string (0x prefixed)
+ *
+ * @example
+ * ```typescript
+ * toHexAddress('0x049d36570d4e46f48e99674bd3fcc84644ddd6b9')
+ * // => '0x049d36570d4e46f48e99674bd3fcc84644ddd6b9'
+ *
+ * toHexAddress('2009894490435840142178903814830')
+ * // => '0x049d36570d4e46f48e99674bd3fcc84644ddd6b9'
+ * ```
+ */
+export function toHexAddress(address) {
+    if (typeof address === 'bigint') {
+        return num.toHex(address);
+    }
+    if (address.startsWith('0x')) {
+        return address;
+    }
+    return num.toHex(address);
+}
+//# sourceMappingURL=address.js.map

package/dist/address.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.js","sourceRoot":"","sources":["../src/address.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,YAAY,CAAC,OAAwB;IACnD,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QAChC,OAAO,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC5B,CAAC;IACD,IAAI,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,OAAO,OAAO,CAAC;IACjB,CAAC;IACD,OAAO,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AAC5B,CAAC"}

package/dist/call-format.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Call format conversion utilities for wallet connector compatibility.
+ *
+ * starknet.js uses camelCase (`contractAddress`, `entrypoint`) but the
+ * Starknet JSON-RPC spec uses snake_case (`contract_address`, `entry_point`).
+ * Some wallet connectors (e.g., starknetkit) validate against the RPC format.
+ *
+ * @module
+ */
+import { type Call } from 'starknet';
+/**
+ * Call object in snake_case format (JSON-RPC spec format).
+ *
+ * Used by some wallet connectors like starknetkit that validate
+ * against the raw RPC format rather than starknet.js types.
+ */
+export interface CallRpc {
+    contract_address: string;
+    entry_point: string;
+    calldata: string[];
+}
+/**
+ * Converts a starknet.js Call to snake_case RPC format.
+ *
+ * Also normalizes all addresses and calldata values to hex format
+ * for maximum wallet connector compatibility.
+ *
+ * Use this when your wallet connector (e.g., starknetkit) expects
+ * snake_case field names instead of starknet.js camelCase format.
+ *
+ * @param call - starknet.js Call object (camelCase)
+ * @returns Call in RPC format (snake_case) with hex-formatted values
+ *
+ * @example
+ * ```typescript
+ * import { toRpcCall } from '@the-situation/sdk';
+ *
+ * const trade = await market.prepareTrade({ targetMean: 105 });
+ * const rpcCalls = trade.calls.map(toRpcCall);
+ * await account.execute(rpcCalls);
+ * ```
+ */
+export declare function toRpcCall(call: Call): CallRpc;
+/**
+ * Converts an array of starknet.js Calls to snake_case RPC format.
+ *
+ * Convenience wrapper for `calls.map(toRpcCall)`.
+ *
+ * @param calls - Array of starknet.js Call objects (camelCase)
+ * @returns Array of Calls in RPC format (snake_case)
+ *
+ * @example
+ * ```typescript
+ * import { toRpcCalls } from '@the-situation/sdk';
+ *
+ * const trade = await market.prepareTrade({ targetMean: 105 });
+ * await account.execute(toRpcCalls(trade.calls));
+ * ```
+ */
+export declare function toRpcCalls(calls: Call[]): CallRpc[];
+//# sourceMappingURL=call-format.d.ts.map

package/dist/call-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-format.d.ts","sourceRoot":"","sources":["../src/call-format.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,KAAK,IAAI,EAAO,MAAM,UAAU,CAAC;AAG1C;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAmBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAM7C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAEnD"}