@magnaflow/contract-sdk 1.0.1

package/README.md

@@ -0,0 +1,64 @@
+# @magnaflow/contract-sdk
+
+Contract call helpers built on top of `@magnaflow/chain-provider`.
+
+## What It Provides
+
+- `ContractManager` for low-level read, write, and gas estimation
+- `ContractCaller` as a thin convenience wrapper
+- EIP-712 digest signing with `signDigest`
+- Standard MagnaFlow error selector parsing
+- Bundled ABIs for payout and ERC-20 flows
+
+## Install
+
+```bash
+npm install @magnaflow/contract-sdk
+```
+
+## Key Exports
+
+- `ContractManager`
+- `ContractCaller`
+- `signDigest`
+- `parseEvmError`
+- `parseContractError`
+- `createFriendlyErrorMessage`
+- `MAGNAFLOW_ERROR_SELECTORS`
+- `payout_new_abi`
+- `ORDER_STRUCT_TYPE`
+- `ERC20_ABI`
+
+## Example
+
+```ts
+import { ContractCaller, ERC20_ABI } from '@magnaflow/contract-sdk';
+import { createChainProvider } from '@magnaflow/chain-provider';
+
+const provider = createChainProvider(chainConfig, process.env.MNEMONIC);
+const caller = new ContractCaller(provider);
+
+const balance = await caller.call({
+  address: '0x55d398326f99059fF775485246999027B3197955',
+  abi: ERC20_ABI,
+  functionName: 'balanceOf',
+  args: ['0x1234...'],
+});
+```
+
+## Notes
+
+- EVM contract read/write is implemented.
+- Tron contract read/write is not implemented in the current release and should be treated as unsupported.
+
+## Development
+
+```bash
+bunx nx run contract-sdk:lint
+bunx nx run contract-sdk:test
+bunx nx run contract-sdk:build
+```
+
+## License
+
+MIT

package/dist/contract-caller.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Contract caller for simplified contract interactions
+ */
+import type { ChainProvider } from '@magnaflow/chain-provider';
+import type { ContractCallParams, ContractWriteParams } from './types';
+/**
+ * Contract caller utility
+ */
+export declare class ContractCaller {
+    private contractManager;
+    constructor(provider: ChainProvider);
+    /**
+     * Call contract view function
+     */
+    call<T = unknown>(params: ContractCallParams): Promise<T>;
+    /**
+     * Send contract transaction
+     */
+    send(params: ContractWriteParams): Promise<import("./types").ContractTransactionResult>;
+    /**
+     * Estimate gas for contract call
+     */
+    estimateGas(params: ContractCallParams): Promise<bigint>;
+}
+//# sourceMappingURL=contract-caller.d.ts.map

package/dist/contract-caller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-caller.d.ts","sourceRoot":"","sources":["../src/contract-caller.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEvE;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,eAAe,CAAkB;gBAE7B,QAAQ,EAAE,aAAa;IAInC;;OAEG;IACG,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;IAI/D;;OAEG;IACG,IAAI,CAAC,MAAM,EAAE,mBAAmB;IAItC;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;CAG/D"}

package/dist/contract-caller.js

@@ -0,0 +1,30 @@
+/**
+ * Contract caller for simplified contract interactions
+ */
+import { ContractManager } from './contract-manager';
+/**
+ * Contract caller utility
+ */
+export class ContractCaller {
+    constructor(provider) {
+        this.contractManager = new ContractManager(provider);
+    }
+    /**
+     * Call contract view function
+     */
+    async call(params) {
+        return await this.contractManager.readContract(params);
+    }
+    /**
+     * Send contract transaction
+     */
+    async send(params) {
+        return await this.contractManager.writeContract(params);
+    }
+    /**
+     * Estimate gas for contract call
+     */
+    async estimateGas(params) {
+        return await this.contractManager.estimateContractGas(params);
+    }
+}

package/dist/contract-manager.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Contract manager for unified contract interactions
+ */
+import type { ChainProvider } from '@magnaflow/chain-provider';
+import type { ContractCallParams, ContractWriteParams, ContractTransactionResult } from './types';
+/**
+ * Contract manager
+ */
+export declare class ContractManager {
+    private provider;
+    constructor(provider: ChainProvider);
+    /**
+     * Read from contract
+     */
+    readContract<T = unknown>(params: ContractCallParams): Promise<T>;
+    /**
+     * Write to contract
+     */
+    writeContract(params: ContractWriteParams): Promise<ContractTransactionResult>;
+    /**
+     * Estimate gas for contract call
+     */
+    estimateContractGas(params: ContractCallParams): Promise<bigint>;
+    /**
+     * Get contract instance (for advanced usage)
+     */
+    getProvider(): ChainProvider;
+}
+//# sourceMappingURL=contract-manager.d.ts.map

package/dist/contract-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-manager.d.ts","sourceRoot":"","sources":["../src/contract-manager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAGlG;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAgB;gBAEpB,QAAQ,EAAE,aAAa;IAInC;;OAEG;IACG,YAAY,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;IAiBvE;;OAEG;IACG,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IA4CpF;;OAEG;IACG,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IAuBtE;;OAEG;IACH,WAAW,IAAI,aAAa;CAG7B"}

package/dist/contract-manager.js

@@ -0,0 +1,101 @@
+/**
+ * Contract manager for unified contract interactions
+ */
+/**
+ * Contract manager
+ */
+export class ContractManager {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /**
+     * Read from contract
+     */
+    async readContract(params) {
+        if (this.provider.getChainType() === 'evm') {
+            const evmProvider = this.provider;
+            const publicClient = evmProvider.getPublicClient();
+            return (await publicClient.readContract({
+                address: params.address,
+                abi: params.abi,
+                functionName: params.functionName,
+                args: params.args,
+            }));
+        }
+        else {
+            // Tron contract read
+            throw new Error('Tron contract read not yet implemented');
+        }
+    }
+    /**
+     * Write to contract
+     */
+    async writeContract(params) {
+        if (this.provider.getChainType() === 'evm') {
+            const evmProvider = this.provider;
+            const walletClient = evmProvider.getWalletClient();
+            if (!walletClient) {
+                throw new Error('Wallet client not available');
+            }
+            const writeParams = {
+                address: params.address,
+                abi: params.abi,
+                functionName: params.functionName,
+                args: params.args,
+            };
+            if (params.value !== undefined) {
+                writeParams.value = params.value;
+            }
+            if (params.gasLimit !== undefined) {
+                writeParams.gas = params.gasLimit;
+            }
+            if (params.gasPrice !== undefined) {
+                writeParams.gasPrice = params.gasPrice;
+            }
+            if (params.maxFeePerGas !== undefined) {
+                writeParams.maxFeePerGas = params.maxFeePerGas;
+            }
+            if (params.maxPriorityFeePerGas !== undefined) {
+                writeParams.maxPriorityFeePerGas = params.maxPriorityFeePerGas;
+            }
+            const hash = await walletClient.writeContract(writeParams);
+            return {
+                hash,
+                chainType: 'evm',
+            };
+        }
+        else {
+            // Tron contract write
+            throw new Error('Tron contract write not yet implemented');
+        }
+    }
+    /**
+     * Estimate gas for contract call
+     */
+    async estimateContractGas(params) {
+        if (this.provider.getChainType() === 'evm') {
+            const evmProvider = this.provider;
+            const publicClient = evmProvider.getPublicClient();
+            const estimateParams = {
+                address: params.address,
+                abi: params.abi,
+                functionName: params.functionName,
+                args: params.args,
+            };
+            if (params.value !== undefined) {
+                estimateParams.value = params.value;
+            }
+            return await publicClient.estimateContractGas(estimateParams);
+        }
+        else {
+            // Tron doesn't have gas estimation
+            return BigInt(0);
+        }
+    }
+    /**
+     * Get contract instance (for advanced usage)
+     */
+    getProvider() {
+        return this.provider;
+    }
+}

package/dist/eip712-signer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sign digest with private key
+ * Note: This is a placeholder. In practice, use viem's account signing
+ * or implement with @noble/secp256k1 for direct private key signing
+ */
+export declare function signDigest(digest: string, privateKey: string): Promise<`0x${string}`>;
+//# sourceMappingURL=eip712-signer.d.ts.map

package/dist/eip712-signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eip712-signer.d.ts","sourceRoot":"","sources":["../src/eip712-signer.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAc3F"}

package/dist/eip712-signer.js

@@ -0,0 +1,20 @@
+import { sign } from 'viem/accounts';
+import { bytesToHex, concatHex } from 'viem';
+/**
+ * Sign digest with private key
+ * Note: This is a placeholder. In practice, use viem's account signing
+ * or implement with @noble/secp256k1 for direct private key signing
+ */
+export async function signDigest(digest, privateKey) {
+    const digestHex = digest.startsWith('0x') ? digest : `0x${digest}`;
+    const pk = privateKey.startsWith('0x') ? privateKey : `0x${privateKey}`;
+    const signature = await sign({
+        hash: digestHex,
+        privateKey: pk,
+    });
+    let v = Number(signature.v ?? 0);
+    if (v < 27) {
+        v = v + 27;
+    }
+    return concatHex([signature.r, signature.s, bytesToHex(Uint8Array.of(v))]);
+}

package/dist/erc20-abi.d.ts

@@ -0,0 +1,59 @@
+export declare const ERC20_ABI: readonly [{
+    readonly name: "balanceOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "approve";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "allowance";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "transfer";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}];
+//# sourceMappingURL=erc20-abi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"erc20-abi.d.ts","sourceRoot":"","sources":["../src/erc20-abi.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsCZ,CAAC"}

package/dist/erc20-abi.js

@@ -0,0 +1,39 @@
+export const ERC20_ABI = [
+    {
+        name: 'balanceOf',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [{ name: 'owner', type: 'address' }],
+        outputs: [{ name: '', type: 'uint256' }],
+    },
+    {
+        name: 'approve',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'spender', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+        ],
+        outputs: [{ name: '', type: 'bool' }],
+    },
+    {
+        name: 'allowance',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [
+            { name: 'owner', type: 'address' },
+            { name: 'spender', type: 'address' },
+        ],
+        outputs: [{ name: '', type: 'uint256' }],
+    },
+    {
+        name: 'transfer',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'to', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+        ],
+        outputs: [{ name: '', type: 'bool' }],
+    },
+];

package/dist/error-handler.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Contract error handler utilities
+ * Provides functions to parse and format contract errors
+ */
+/**
+ * MagnaFlow contract error selector mapping
+ * Error selector = first 4 bytes of keccak256("ErrorName()")
+ */
+export declare const MAGNAFLOW_ERROR_SELECTORS: Record<string, string>;
+/**
+ * Parse error information from EVM contract error
+ * @param error - EVM error object (from ethers, viem, etc.)
+ * @param errorSelectors - Optional custom error selector mapping (defaults to MAGNAFLOW_ERROR_SELECTORS)
+ * @returns Parsed error message
+ */
+export declare function parseEvmError(error: any, errorSelectors?: Record<string, string>): string;
+/**
+ * Parse error information from contract result array
+ * Typically used for Tron contract errors or contract return values
+ * @param contractResult - The result array returned by the contract
+ * @param errorSelectors - Optional custom error selector mapping (defaults to MAGNAFLOW_ERROR_SELECTORS)
+ * @returns Parsed error information
+ */
+export declare function parseContractError(contractResult: any[], errorSelectors?: Record<string, string>): string;
+/**
+ * Create a friendly error message from an error object
+ * @param error - Original error object
+ * @param defaultMessage - Default error message (default: 'Operation failed')
+ * @param errorSelectors - Optional custom error selector mapping (defaults to MAGNAFLOW_ERROR_SELECTORS)
+ * @returns Friendly error message
+ */
+export declare function createFriendlyErrorMessage(error: any, defaultMessage?: string, errorSelectors?: Record<string, string>): string;
+//# sourceMappingURL=error-handler.d.ts.map

package/dist/error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../src/error-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAc5D,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,GAAG,EACV,cAAc,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAA6B,GACjE,MAAM,CAwDR;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,cAAc,EAAE,GAAG,EAAE,EACrB,cAAc,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAA6B,GACjE,MAAM,CAsBR;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,GAAG,EACV,cAAc,GAAE,MAA2B,EAC3C,cAAc,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAA6B,GACjE,MAAM,CAUR"}

package/dist/error-handler.js

@@ -0,0 +1,123 @@
+/**
+ * Contract error handler utilities
+ * Provides functions to parse and format contract errors
+ */
+/**
+ * MagnaFlow contract error selector mapping
+ * Error selector = first 4 bytes of keccak256("ErrorName()")
+ */
+export const MAGNAFLOW_ERROR_SELECTORS = {
+    '0x7db491eb': 'InvalidInputLength - Input length mismatch (array length inconsistent or empty)',
+    '0x9c358fad': 'FundTransferFailed - Transfer failed (insufficient balance or allowance)',
+    '0xf4d678b8': 'InsufficientBalance - Insufficient balance',
+    '0x599989d2': 'InsufficientMerchantBalance - Insufficient merchant balance (cannot pay fee)',
+    '0x4b692736': 'InvalidEd25519PublicKey - Invalid Ed25519 public key',
+    '0x3a81d6fc': 'AlreadyRegistered - Already registered',
+    '0x8baa579f': 'InvalidSignature - Signature verification failed',
+    '0x56d69198': 'InvalidFeeRate - Invalid fee rate',
+    '0x2c5211c6': 'InvalidAmount - Invalid amount',
+    '0xe6f2de87': 'InvalidStableCoin - Not a stablecoin',
+    '0x9c8d2cd2': 'InvalidRecipient - Invalid recipient address',
+    '0xb89fe006': 'InvalidWhitelist - Not in whitelist',
+    '0xc0b6c919': 'InvalidMerchant - Invalid merchant address',
+};
+/**
+ * Parse error information from EVM contract error
+ * @param error - EVM error object (from ethers, viem, etc.)
+ * @param errorSelectors - Optional custom error selector mapping (defaults to MAGNAFLOW_ERROR_SELECTORS)
+ * @returns Parsed error message
+ */
+export function parseEvmError(error, errorSelectors = MAGNAFLOW_ERROR_SELECTORS) {
+    if (!error) {
+        return 'Unknown error';
+    }
+    // Try to extract error selector from error.data
+    let errorSelector = null;
+    // ethers v6 error format: error.data may be a string
+    if (error.data) {
+        if (typeof error.data === 'string') {
+            errorSelector = error.data;
+        }
+        else if (error.data.error?.data) {
+            // In some cases error data is in error.data.error.data
+            errorSelector = error.data.error.data;
+        }
+        else if (error.data.originalError?.data) {
+            // In some cases error data is in error.data.originalError.data
+            errorSelector = error.data.originalError.data;
+        }
+    }
+    // If error.data is a string, extract error selector (first 4 bytes = 10 characters)
+    if (errorSelector) {
+        // Ensure 0x prefix exists
+        let selector;
+        if (errorSelector.startsWith('0x')) {
+            // If length >= 10, take first 10 characters; otherwise use full string
+            selector = errorSelector.length >= 10 ? errorSelector.slice(0, 10) : errorSelector;
+        }
+        else {
+            // If no 0x prefix, add it and take first 8 characters
+            selector = `0x${errorSelector.slice(0, 8)}`;
+        }
+        if (errorSelectors[selector]) {
+            return errorSelectors[selector];
+        }
+    }
+    // Try to extract error selector from error message
+    if (error.message) {
+        // Look for pattern like "0x..." (8 hex characters)
+        const match = error.message.match(/0x[a-fA-F0-9]{8}/);
+        if (match) {
+            const selector = match[0];
+            if (errorSelectors[selector]) {
+                return errorSelectors[selector];
+            }
+        }
+    }
+    // If cannot parse, return original error message or default message
+    if (error.message) {
+        return error.message;
+    }
+    return 'Unknown error';
+}
+/**
+ * Parse error information from contract result array
+ * Typically used for Tron contract errors or contract return values
+ * @param contractResult - The result array returned by the contract
+ * @param errorSelectors - Optional custom error selector mapping (defaults to MAGNAFLOW_ERROR_SELECTORS)
+ * @returns Parsed error information
+ */
+export function parseContractError(contractResult, errorSelectors = MAGNAFLOW_ERROR_SELECTORS) {
+    if (!contractResult || contractResult.length === 0) {
+        return 'Unknown error';
+    }
+    // Contract errors typically return an error selector (4 bytes, 8 hex characters)
+    const errorSelector = Array.isArray(contractResult) ? contractResult[0] : contractResult;
+    if (typeof errorSelector === 'string') {
+        // Ensure 0x prefix exists
+        const selector = errorSelector.startsWith('0x') ? errorSelector : `0x${errorSelector}`;
+        // Check if it's a known error selector
+        if (errorSelectors[selector]) {
+            return errorSelectors[selector];
+        }
+        // If not a known error, return the raw selector
+        return `Unknown error: ${selector}`;
+    }
+    return 'Unable to parse error information';
+}
+/**
+ * Create a friendly error message from an error object
+ * @param error - Original error object
+ * @param defaultMessage - Default error message (default: 'Operation failed')
+ * @param errorSelectors - Optional custom error selector mapping (defaults to MAGNAFLOW_ERROR_SELECTORS)
+ * @returns Friendly error message
+ */
+export function createFriendlyErrorMessage(error, defaultMessage = 'Operation failed', errorSelectors = MAGNAFLOW_ERROR_SELECTORS) {
+    const parsedError = parseEvmError(error, errorSelectors);
+    // If parsed error differs from default message, use parsed error
+    if (parsedError !== 'Unknown error' && parsedError !== error.message) {
+        return `${defaultMessage}: ${parsedError}`;
+    }
+    // Otherwise use original error message or default message
+    return error?.message || defaultMessage;
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @magnaflow/contract-sdk
+ * Standardized contract interaction SDK for multi-chain smart contracts
+ */
+export type { Abi, EIP712Domain, ContractCallParams, ContractWriteParams, ContractTransactionResult, } from './types';
+export { ContractManager } from './contract-manager';
+export { ContractCaller } from './contract-caller';
+export { signDigest } from './eip712-signer';
+export { parseEvmError, parseContractError, createFriendlyErrorMessage, MAGNAFLOW_ERROR_SELECTORS, } from './error-handler';
+export { payout_new_abi, ORDER_STRUCT_TYPE } from './payout-abi';
+export { ERC20_ABI } from './erc20-abi';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EACV,GAAG,EACH,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACnB,yBAAyB,GAC1B,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGnD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG7C,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,0BAA0B,EAC1B,yBAAyB,GAC1B,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+/**
+ * @magnaflow/contract-sdk
+ * Standardized contract interaction SDK for multi-chain smart contracts
+ */
+// Contract manager
+export { ContractManager } from './contract-manager';
+// Contract caller
+export { ContractCaller } from './contract-caller';
+// EIP-712 signing
+export { signDigest } from './eip712-signer';
+// Error handling
+export { parseEvmError, parseContractError, createFriendlyErrorMessage, MAGNAFLOW_ERROR_SELECTORS, } from './error-handler';
+// ABIs
+export { payout_new_abi, ORDER_STRUCT_TYPE } from './payout-abi';
+export { ERC20_ABI } from './erc20-abi';