@snowbridge/provider-viem 1.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+
+
+> @snowbridge/provider-viem@1.0.0 build /Users/alistairsingh/c/snowbridge/web/packages/provider-viem
+> tsc --build --force
+

package/.turbo/turbo-format.log

@@ -0,0 +1,6 @@
+
+
+> @snowbridge/provider-viem@1.0.0 format /Users/alistairsingh/c/snowbridge/web/packages/provider-viem
+> prettier src --write
+
+src/index.tssrc/index.ts 106ms (unchanged)

package/README.md

@@ -0,0 +1,3 @@
+# `@snowbridge/provider-viem`
+
+`viem` implementation of the Snowbridge `EthereumProvider` interface.

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import type { Abi, Address, Hex, PublicClient, TransactionReceipt, TransactionRequest } from "viem";
+import type { DepositParamsStruct, EthereumProvider, EthereumProviderTypes, FeeData, GatewayV1OutboundMessageAccepted, GatewayV2OutboundMessageAccepted, IGatewayV1, IGatewayV2, L1AdapterDepositParams, L1LegacySwapRouterExactOutputSingleParams, L1SwapRouterExactOutputSingleParams, MultiAddressStruct, SendParamsStruct, SwapParamsStruct } from "@snowbridge/base-types";
+export type ViemContractTransaction = TransactionRequest & {
+    account?: Address;
+};
+export type ViemContract = {
+    getAddress(): Promise<Address>;
+    removeAllListeners(): Promise<void>;
+    [key: string]: unknown;
+};
+export interface ViemProviderTypes extends EthereumProviderTypes {
+    Connection: PublicClient;
+    Contract: ViemContract;
+    Abi: Abi;
+    TransactionReceipt: TransactionReceipt;
+    ContractTransaction: ViemContractTransaction;
+}
+export declare class ViemEthereumProvider implements EthereumProvider<ViemProviderTypes> {
+    readonly providerTypes: ViemProviderTypes;
+    createProvider(url: string): PublicClient;
+    destroyProvider(provider: PublicClient): void;
+    destroyContract(_contract: ViemContract): Promise<void>;
+    connectContract(address: string, abi: Abi, provider: PublicClient): ViemContract;
+    erc20Balance(provider: PublicClient, tokenAddress: string, owner: string, spender: string): Promise<{
+        balance: bigint;
+        gatewayAllowance: bigint;
+    }>;
+    gatewayV1SendToken(_provider: PublicClient, gatewayAddress: string, sender: string, token: string, destinationChain: number, destinationAddress: MultiAddressStruct, destinationFee: bigint, amount: bigint, value: bigint): Promise<ViemContractTransaction>;
+    gatewayV2RegisterToken(_provider: PublicClient, gatewayAddress: string, sender: string, token: string, network: number, executionFee: bigint, relayerFee: bigint, value: bigint): Promise<ViemContractTransaction>;
+    gatewayV2CreateAgent(_provider: PublicClient, gatewayAddress: string, id: string): Promise<ViemContractTransaction>;
+    gatewayV2SendMessage(_provider: PublicClient, gatewayAddress: string, sender: string, xcm: Uint8Array, assets: string[], claimer: Uint8Array, executionFee: bigint, relayerFee: bigint, value: bigint): Promise<ViemContractTransaction>;
+    l2AdapterSendEtherAndCall(_provider: PublicClient, adapterAddress: string, sender: string, params: DepositParamsStruct, sendParams: SendParamsStruct, recipient: string, topic: string, value?: bigint): Promise<ViemContractTransaction>;
+    l2AdapterSendTokenAndCall(_provider: PublicClient, adapterAddress: string, sender: string, params: DepositParamsStruct, swapParams: SwapParamsStruct, sendParams: SendParamsStruct, recipient: string, topic: string): Promise<ViemContractTransaction>;
+    evmParachainTransferAssetsUsingTypeAndThenAddress(_provider: PublicClient, precompileAddress: string, sourceAccount: string, destination: [number, string[]], assets: [string, bigint][], assetsTransferType: number, remoteFeesIdIndex: number, feesTransferType: number, customXcmHex: string): Promise<ViemContractTransaction>;
+    encodeFunctionData(abi: Abi | readonly [string, ...string[]], method: string, args: readonly unknown[]): Hex;
+    decodeFunctionResult<T = unknown>(abi: Abi | readonly [string, ...string[]], method: string, data: string): T;
+    encodeNativeAsset(tokenAddress: string, amount: bigint): Hex;
+    l1AdapterDepositNativeEther(params: L1AdapterDepositParams, recipient: string, topic: string): Hex;
+    l1AdapterDepositToken(params: L1AdapterDepositParams, recipient: string, topic: string): Hex;
+    l1SwapRouterExactOutputSingle(params: L1SwapRouterExactOutputSingleParams): Hex;
+    l1LegacySwapRouterExactOutputSingle(params: L1LegacySwapRouterExactOutputSingleParams): Hex;
+    beneficiaryMultiAddress(beneficiary: string): MultiAddressStruct;
+    estimateGas(provider: PublicClient, tx: ViemContractTransaction): Promise<bigint>;
+    getTransactionCount(provider: PublicClient, address: string, blockTag?: "latest" | "pending"): Promise<number>;
+    getBalance(provider: PublicClient, address: string): Promise<bigint>;
+    getFeeData(provider: PublicClient): Promise<FeeData>;
+    parseUnits(value: string, decimals: number): bigint;
+    gatewayOperatingMode(gateway: ViemContract & (IGatewayV1 | IGatewayV2)): Promise<bigint>;
+    gatewayChannelOperatingModeOf(gateway: ViemContract & IGatewayV1, channelId: string): Promise<bigint>;
+    isContractAddress(provider: PublicClient, address: string): Promise<boolean>;
+    scanGatewayV1OutboundMessageAccepted(receipt: TransactionReceipt): GatewayV1OutboundMessageAccepted | null;
+    scanGatewayV2OutboundMessageAccepted(receipt: TransactionReceipt): GatewayV2OutboundMessageAccepted | null;
+}
+//# 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":"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"}

package/dist/index.js

@@ -0,0 +1,397 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViemEthereumProvider = void 0;
+const viem_1 = require("viem");
+const base_types_1 = require("@snowbridge/base-types");
+function toAddress(value) {
+    return (0, viem_1.getAddress)(value);
+}
+function asAbi(abi) {
+    if (Array.isArray(abi) && abi.every((item) => typeof item === "string")) {
+        return (0, viem_1.parseAbi)(abi);
+    }
+    return abi;
+}
+function toBytesHex(value) {
+    return typeof value === "string" ? value : (0, viem_1.toHex)(value);
+}
+function normalizeMultiAddress(address) {
+    return {
+        kind: address.kind,
+        data: address.data,
+    };
+}
+function normalizeDepositParams(params) {
+    return {
+        ...params,
+        inputToken: toAddress(params.inputToken),
+        outputToken: toAddress(params.outputToken),
+    };
+}
+function normalizeSendParams(sendParams) {
+    return {
+        xcm: toBytesHex(sendParams.xcm),
+        assets: sendParams.assets.map((asset) => asset),
+        claimer: toBytesHex(sendParams.claimer),
+        executionFee: sendParams.executionFee,
+        relayerFee: sendParams.relayerFee,
+    };
+}
+function normalizeSwapParams(swapParams) {
+    return {
+        ...swapParams,
+        router: toAddress(swapParams.router),
+        callData: swapParams.callData,
+    };
+}
+function normalizeDestination(destination) {
+    return [destination[0], destination[1].map((item) => item)];
+}
+function createReadOnlyContract(address, abi, provider) {
+    const normalizedAbi = asAbi(abi);
+    return new Proxy({
+        async getAddress() {
+            return address;
+        },
+        async removeAllListeners() { },
+    }, {
+        get(target, prop, receiver) {
+            if (typeof prop !== "string") {
+                return Reflect.get(target, prop, receiver);
+            }
+            if (prop in target) {
+                return Reflect.get(target, prop, receiver);
+            }
+            const fn = (async (...args) => {
+                return await provider.readContract({
+                    address,
+                    abi: normalizedAbi,
+                    functionName: prop,
+                    args,
+                });
+            });
+            fn.staticCall = async (...args) => {
+                const result = await provider.simulateContract({
+                    address,
+                    abi: normalizedAbi,
+                    functionName: prop,
+                    args,
+                });
+                return result.result;
+            };
+            return fn;
+        },
+    });
+}
+class ViemEthereumProvider {
+    createProvider(url) {
+        return (0, viem_1.createPublicClient)({
+            transport: url.startsWith("http") ? (0, viem_1.http)(url) : (0, viem_1.webSocket)(url),
+        });
+    }
+    destroyProvider(provider) {
+        const transport = provider.transport;
+        transport.value?.close?.();
+    }
+    async destroyContract(_contract) { }
+    connectContract(address, abi, provider) {
+        return createReadOnlyContract(toAddress(address), asAbi(abi), provider);
+    }
+    async erc20Balance(provider, tokenAddress, owner, spender) {
+        const [balance, gatewayAllowance] = await Promise.all([
+            provider.readContract({
+                address: toAddress(tokenAddress),
+                abi: asAbi(base_types_1.IERC20_ABI),
+                functionName: "balanceOf",
+                args: [toAddress(owner)],
+            }),
+            provider.readContract({
+                address: toAddress(tokenAddress),
+                abi: asAbi(base_types_1.IERC20_ABI),
+                functionName: "allowance",
+                args: [toAddress(owner), toAddress(spender)],
+            }),
+        ]);
+        return {
+            balance: balance,
+            gatewayAllowance: gatewayAllowance,
+        };
+    }
+    async gatewayV1SendToken(_provider, gatewayAddress, sender, token, destinationChain, destinationAddress, destinationFee, amount, value) {
+        return {
+            to: toAddress(gatewayAddress),
+            account: toAddress(sender),
+            value,
+            data: this.encodeFunctionData(asAbi(base_types_1.IGATEWAY_V1_ABI), "sendToken", [
+                toAddress(token),
+                BigInt(destinationChain),
+                normalizeMultiAddress(destinationAddress),
+                destinationFee,
+                amount,
+            ]),
+        };
+    }
+    async gatewayV2RegisterToken(_provider, gatewayAddress, sender, token, network, executionFee, relayerFee, value) {
+        return {
+            to: toAddress(gatewayAddress),
+            account: toAddress(sender),
+            value,
+            data: this.encodeFunctionData(asAbi(base_types_1.IGATEWAY_V2_ABI), "v2_registerToken", [toAddress(token), BigInt(network), executionFee, relayerFee]),
+        };
+    }
+    async gatewayV2CreateAgent(_provider, gatewayAddress, id) {
+        return {
+            to: toAddress(gatewayAddress),
+            data: this.encodeFunctionData(asAbi(base_types_1.IGATEWAY_V2_ABI), "v2_createAgent", [
+                id,
+            ]),
+        };
+    }
+    async gatewayV2SendMessage(_provider, gatewayAddress, sender, xcm, assets, claimer, executionFee, relayerFee, value) {
+        return {
+            to: toAddress(gatewayAddress),
+            account: toAddress(sender),
+            value,
+            data: this.encodeFunctionData(asAbi(base_types_1.IGATEWAY_V2_ABI), "v2_sendMessage", [
+                toBytesHex(xcm),
+                assets.map((asset) => asset),
+                toBytesHex(claimer),
+                executionFee,
+                relayerFee,
+            ]),
+        };
+    }
+    async l2AdapterSendEtherAndCall(_provider, adapterAddress, sender, params, sendParams, recipient, topic, value) {
+        return {
+            to: toAddress(adapterAddress),
+            account: toAddress(sender),
+            value,
+            data: this.encodeFunctionData(asAbi(base_types_1.SNOWBRIDGE_L2_ADAPTOR_ABI), "sendEtherAndCall", [
+                normalizeDepositParams(params),
+                normalizeSendParams(sendParams),
+                toAddress(recipient),
+                topic,
+            ]),
+        };
+    }
+    async l2AdapterSendTokenAndCall(_provider, adapterAddress, sender, params, swapParams, sendParams, recipient, topic) {
+        return {
+            to: toAddress(adapterAddress),
+            account: toAddress(sender),
+            data: this.encodeFunctionData(asAbi(base_types_1.SNOWBRIDGE_L2_ADAPTOR_ABI), "sendTokenAndCall", [
+                normalizeDepositParams(params),
+                normalizeSwapParams(swapParams),
+                normalizeSendParams(sendParams),
+                toAddress(recipient),
+                topic,
+            ]),
+        };
+    }
+    async evmParachainTransferAssetsUsingTypeAndThenAddress(_provider, precompileAddress, sourceAccount, destination, assets, assetsTransferType, remoteFeesIdIndex, feesTransferType, customXcmHex) {
+        return {
+            to: toAddress(precompileAddress),
+            account: toAddress(sourceAccount),
+            data: this.encodeFunctionData(asAbi(base_types_1.MOONBEAM_PALLET_XCM_PRECOMPILE_ABI), "transferAssetsUsingTypeAndThenAddress", [
+                normalizeDestination(destination),
+                assets.map(([asset, amount]) => [toAddress(asset), amount]),
+                assetsTransferType,
+                remoteFeesIdIndex,
+                feesTransferType,
+                customXcmHex,
+            ]),
+        };
+    }
+    encodeFunctionData(abi, method, args) {
+        return (0, viem_1.encodeFunctionData)({
+            abi: asAbi(abi),
+            functionName: method,
+            args: [...args],
+        });
+    }
+    decodeFunctionResult(abi, method, data) {
+        return (0, viem_1.decodeFunctionResult)({
+            abi: asAbi(abi),
+            functionName: method,
+            data: data,
+        });
+    }
+    encodeNativeAsset(tokenAddress, amount) {
+        return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)("uint8,address,uint128"), [
+            0,
+            toAddress(tokenAddress),
+            amount,
+        ]);
+    }
+    l1AdapterDepositNativeEther(params, recipient, topic) {
+        return this.encodeFunctionData(asAbi(base_types_1.SNOWBRIDGE_L1_ADAPTOR_ABI), "depositNativeEther", [normalizeDepositParams(params), toAddress(recipient), topic]);
+    }
+    l1AdapterDepositToken(params, recipient, topic) {
+        return this.encodeFunctionData(asAbi(base_types_1.SNOWBRIDGE_L1_ADAPTOR_ABI), "depositToken", [normalizeDepositParams(params), toAddress(recipient), topic]);
+    }
+    l1SwapRouterExactOutputSingle(params) {
+        return this.encodeFunctionData(asAbi(base_types_1.SWAP_ROUTER_ABI), "exactOutputSingle", [
+            {
+                ...params,
+                tokenIn: toAddress(params.tokenIn),
+                tokenOut: toAddress(params.tokenOut),
+                recipient: toAddress(params.recipient),
+            },
+        ]);
+    }
+    l1LegacySwapRouterExactOutputSingle(params) {
+        return this.encodeFunctionData(asAbi(base_types_1.SWAP_LEGACY_ROUTER_ABI), "exactOutputSingle", [
+            {
+                ...params,
+                tokenIn: toAddress(params.tokenIn),
+                tokenOut: toAddress(params.tokenOut),
+                recipient: toAddress(params.recipient),
+            },
+        ]);
+    }
+    beneficiaryMultiAddress(beneficiary) {
+        let kind;
+        if (/^0x[a-fA-F0-9]{40}$/.test(beneficiary)) {
+            kind = 2;
+        }
+        else if (/^0x[a-fA-F0-9]{64}$/.test(beneficiary)) {
+            kind = 1;
+        }
+        else {
+            throw new Error("Unknown Beneficiary address format.");
+        }
+        let data;
+        switch (kind) {
+            case 1:
+                data = (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)("bytes32"), [
+                    beneficiary,
+                ]);
+                break;
+            case 2:
+                data = (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)("bytes20"), [
+                    beneficiary,
+                ]);
+                break;
+            default:
+                throw new Error(`Unknown Beneficiary kind ${kind}.`);
+        }
+        return { kind, data };
+    }
+    async estimateGas(provider, tx) {
+        return await provider.estimateGas(tx);
+    }
+    async getTransactionCount(provider, address, blockTag = "latest") {
+        return Number(await provider.getTransactionCount({
+            address: toAddress(address),
+            blockTag,
+        }));
+    }
+    async getBalance(provider, address) {
+        return await provider.getBalance({ address: toAddress(address) });
+    }
+    async getFeeData(provider) {
+        const gasPrice = await provider.getGasPrice();
+        try {
+            const fees = await provider.estimateFeesPerGas();
+            return {
+                gasPrice: fees.gasPrice ?? gasPrice,
+                maxFeePerGas: fees.maxFeePerGas ?? null,
+                maxPriorityFeePerGas: fees.maxPriorityFeePerGas ?? null,
+            };
+        }
+        catch {
+            return {
+                gasPrice,
+                maxFeePerGas: null,
+                maxPriorityFeePerGas: null,
+            };
+        }
+    }
+    parseUnits(value, decimals) {
+        return (0, viem_1.parseUnits)(value, decimals);
+    }
+    async gatewayOperatingMode(gateway) {
+        return BigInt(await gateway.operatingMode());
+    }
+    async gatewayChannelOperatingModeOf(gateway, channelId) {
+        return BigInt(await gateway.channelOperatingModeOf(channelId));
+    }
+    async isContractAddress(provider, address) {
+        if (!/^0x[a-fA-F0-9]{40}$/.test(address)) {
+            return false;
+        }
+        try {
+            const code = await provider.getCode({ address: toAddress(address) });
+            return code !== undefined && code !== "0x";
+        }
+        catch {
+            return false;
+        }
+    }
+    scanGatewayV1OutboundMessageAccepted(receipt) {
+        for (const log of receipt.logs) {
+            try {
+                const event = (0, viem_1.decodeEventLog)({
+                    abi: asAbi(base_types_1.IGATEWAY_V1_ABI),
+                    topics: log.topics,
+                    data: log.data,
+                });
+                if (event.eventName === "OutboundMessageAccepted") {
+                    const args = event.args;
+                    if (!args) {
+                        continue;
+                    }
+                    return {
+                        channelId: String(args[0]),
+                        nonce: BigInt(args[1]),
+                        messageId: String(args[2]),
+                        blockHash: receipt.blockHash,
+                        blockNumber: Number(receipt.blockNumber),
+                        txHash: receipt.transactionHash,
+                        txIndex: Number(receipt.transactionIndex),
+                    };
+                }
+            }
+            catch { }
+        }
+        return null;
+    }
+    scanGatewayV2OutboundMessageAccepted(receipt) {
+        for (const log of receipt.logs) {
+            try {
+                const event = (0, viem_1.decodeEventLog)({
+                    abi: asAbi(base_types_1.IGATEWAY_V2_ABI),
+                    topics: log.topics,
+                    data: log.data,
+                });
+                if (event.eventName === "OutboundMessageAccepted") {
+                    const args = event.args;
+                    if (!args) {
+                        continue;
+                    }
+                    return {
+                        nonce: BigInt(args.nonce),
+                        payload: {
+                            origin: args.payload.origin,
+                            assets: args.payload.assets.map((asset) => [
+                                Number(asset.kind),
+                                asset.data,
+                            ]),
+                            xcm: [Number(args.payload.xcm.kind), args.payload.xcm.data],
+                            claimer: args.payload.claimer,
+                            value: BigInt(args.payload.value),
+                            executionFee: BigInt(args.payload.executionFee),
+                            relayerFee: BigInt(args.payload.relayerFee),
+                        },
+                        blockHash: receipt.blockHash,
+                        blockNumber: Number(receipt.blockNumber),
+                        txHash: receipt.transactionHash,
+                        txIndex: Number(receipt.transactionIndex),
+                    };
+                }
+            }
+            catch { }
+        }
+        return null;
+    }
+}
+exports.ViemEthereumProvider = ViemEthereumProvider;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@snowbridge/provider-viem",
+  "version": "1.0.0",
+  "description": "Snowbridge viem provider implementation",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Snowfork/snowbridge.git",
+    "directory": "web/packages/provider-viem"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "devDependencies": {
+    "@types/node": "24.6.2",
+    "@typescript-eslint/eslint-plugin": "8.45.0",
+    "@typescript-eslint/parser": "8.45.0",
+    "eslint": "9.37.0",
+    "eslint-config-prettier": "10.1.8",
+    "prettier": "3.6.2",
+    "ts-node": "10.9.2",
+    "tsconfig-paths": "4.2.0",
+    "typescript": "5.9.3"
+  },
+  "dependencies": {
+    "viem": "^2.38.5",
+    "@snowbridge/base-types": "1.0.0"
+  },
+  "scripts": {
+    "build": "tsc --build --force",
+    "lint": "eslint .",
+    "format": "prettier src --write"
+  }
+}

package/src/index.ts

@@ -0,0 +1,685 @@
+import {
+  createPublicClient,
+  decodeEventLog,
+  decodeFunctionResult,
+  encodeAbiParameters,
+  encodeFunctionData,
+  getAddress,
+  http,
+  parseAbi,
+  parseAbiParameters,
+  parseUnits,
+  toHex,
+  webSocket,
+} from "viem";
+import type {
+  Abi,
+  Address,
+  Hex,
+  Log,
+  PublicClient,
+  TransactionReceipt,
+  TransactionRequest,
+} from "viem";
+import type {
+  BeefyClient,
+  DepositParamsStruct,
+  EthereumProvider,
+  EthereumProviderTypes,
+  FeeData,
+  GatewayV1OutboundMessageAccepted,
+  GatewayV2OutboundMessageAccepted,
+  IGatewayV1,
+  IGatewayV2,
+  IERC20,
+  ISwapQuoter,
+  L1AdapterDepositParams,
+  L1LegacySwapRouterExactOutputSingleParams,
+  L1SwapRouterExactOutputSingleParams,
+  MultiAddressStruct,
+  SendParamsStruct,
+  SwapParamsStruct,
+} from "@snowbridge/base-types";
+import {
+  IERC20_ABI,
+  IGATEWAY_V1_ABI,
+  IGATEWAY_V2_ABI,
+  MOONBEAM_PALLET_XCM_PRECOMPILE_ABI,
+  SNOWBRIDGE_L1_ADAPTOR_ABI,
+  SNOWBRIDGE_L2_ADAPTOR_ABI,
+  SWAP_LEGACY_ROUTER_ABI,
+  SWAP_ROUTER_ABI,
+} from "@snowbridge/base-types";
+
+type ReadonlyFunction = ((...args: unknown[]) => Promise<unknown>) & {
+  staticCall: (...args: unknown[]) => Promise<unknown>;
+};
+
+export type ViemContractTransaction = TransactionRequest & {
+  account?: Address;
+};
+
+export type ViemContract = {
+  getAddress(): Promise<Address>;
+  removeAllListeners(): Promise<void>;
+  [key: string]: unknown;
+};
+
+export interface ViemProviderTypes extends EthereumProviderTypes {
+  Connection: PublicClient;
+  Contract: ViemContract;
+  Abi: Abi;
+  TransactionReceipt: TransactionReceipt;
+  ContractTransaction: ViemContractTransaction;
+}
+
+function toAddress(value: string): Address {
+  return getAddress(value);
+}
+
+function asAbi<TAbi extends Abi>(abi: TAbi): TAbi;
+function asAbi(abi: readonly [string, ...string[]]): Abi;
+function asAbi(abi: Abi | readonly [string, ...string[]]): Abi;
+function asAbi(abi: Abi | readonly [string, ...string[]]): Abi {
+  if (Array.isArray(abi) && abi.every((item) => typeof item === "string")) {
+    return parseAbi(abi);
+  }
+  return abi as Abi;
+}
+
+function toBytesHex(value: string | Uint8Array): Hex {
+  return typeof value === "string" ? (value as Hex) : toHex(value);
+}
+
+function normalizeMultiAddress(
+  address: MultiAddressStruct,
+): MultiAddressStruct {
+  return {
+    kind: address.kind,
+    data: address.data as Hex,
+  };
+}
+
+function normalizeDepositParams<
+  T extends { inputToken: string; outputToken: string },
+>(params: T): T {
+  return {
+    ...params,
+    inputToken: toAddress(params.inputToken),
+    outputToken: toAddress(params.outputToken),
+  };
+}
+
+function normalizeSendParams(sendParams: SendParamsStruct): {
+  xcm: Hex;
+  assets: Hex[];
+  claimer: Hex;
+  executionFee: bigint;
+  relayerFee: bigint;
+} {
+  return {
+    xcm: toBytesHex(sendParams.xcm),
+    assets: sendParams.assets.map((asset) => asset as Hex),
+    claimer: toBytesHex(sendParams.claimer),
+    executionFee: sendParams.executionFee,
+    relayerFee: sendParams.relayerFee,
+  };
+}
+
+function normalizeSwapParams(swapParams: SwapParamsStruct): SwapParamsStruct & {
+  callData: Hex;
+} {
+  return {
+    ...swapParams,
+    router: toAddress(swapParams.router),
+    callData: swapParams.callData as Hex,
+  };
+}
+
+function normalizeDestination(
+  destination: [number, string[]],
+): [number, Hex[]] {
+  return [destination[0], destination[1].map((item) => item as Hex)];
+}
+
+function createReadOnlyContract(
+  address: Address,
+  abi: Abi | readonly [string, ...string[]],
+  provider: PublicClient,
+): ViemContract {
+  const normalizedAbi = asAbi(abi);
+  return new Proxy(
+    {
+      async getAddress() {
+        return address;
+      },
+      async removeAllListeners() {},
+    } as ViemContract,
+    {
+      get(target, prop, receiver) {
+        if (typeof prop !== "string") {
+          return Reflect.get(target, prop, receiver);
+        }
+        if (prop in target) {
+          return Reflect.get(target, prop, receiver);
+        }
+
+        const fn = (async (...args: unknown[]) => {
+          return await provider.readContract({
+            address,
+            abi: normalizedAbi,
+            functionName: prop,
+            args,
+          } as never);
+        }) as ReadonlyFunction;
+
+        fn.staticCall = async (...args: unknown[]) => {
+          const result = await provider.simulateContract({
+            address,
+            abi: normalizedAbi,
+            functionName: prop,
+            args,
+          } as never);
+          return result.result;
+        };
+
+        return fn;
+      },
+    },
+  );
+}
+
+export class ViemEthereumProvider
+  implements EthereumProvider<ViemProviderTypes>
+{
+  declare readonly providerTypes: ViemProviderTypes;
+
+  createProvider(url: string): PublicClient {
+    return createPublicClient({
+      transport: url.startsWith("http") ? http(url) : webSocket(url),
+    });
+  }
+
+  destroyProvider(provider: PublicClient): void {
+    const transport = provider.transport as { value?: { close?: () => void } };
+    transport.value?.close?.();
+  }
+
+  async destroyContract(_contract: ViemContract): Promise<void> {}
+
+  connectContract(
+    address: string,
+    abi: Abi,
+    provider: PublicClient,
+  ): ViemContract {
+    return createReadOnlyContract(toAddress(address), asAbi(abi), provider);
+  }
+
+  async erc20Balance(
+    provider: PublicClient,
+    tokenAddress: string,
+    owner: string,
+    spender: string,
+  ): Promise<{ balance: bigint; gatewayAllowance: bigint }> {
+    const [balance, gatewayAllowance] = await Promise.all([
+      provider.readContract({
+        address: toAddress(tokenAddress),
+        abi: asAbi(IERC20_ABI),
+        functionName: "balanceOf",
+        args: [toAddress(owner)],
+      }),
+      provider.readContract({
+        address: toAddress(tokenAddress),
+        abi: asAbi(IERC20_ABI),
+        functionName: "allowance",
+        args: [toAddress(owner), toAddress(spender)],
+      }),
+    ]);
+    return {
+      balance: balance as bigint,
+      gatewayAllowance: gatewayAllowance as bigint,
+    };
+  }
+
+  async gatewayV1SendToken(
+    _provider: PublicClient,
+    gatewayAddress: string,
+    sender: string,
+    token: string,
+    destinationChain: number,
+    destinationAddress: MultiAddressStruct,
+    destinationFee: bigint,
+    amount: bigint,
+    value: bigint,
+  ): Promise<ViemContractTransaction> {
+    return {
+      to: toAddress(gatewayAddress),
+      account: toAddress(sender),
+      value,
+      data: this.encodeFunctionData(asAbi(IGATEWAY_V1_ABI), "sendToken", [
+        toAddress(token),
+        BigInt(destinationChain),
+        normalizeMultiAddress(destinationAddress),
+        destinationFee,
+        amount,
+      ]),
+    };
+  }
+
+  async gatewayV2RegisterToken(
+    _provider: PublicClient,
+    gatewayAddress: string,
+    sender: string,
+    token: string,
+    network: number,
+    executionFee: bigint,
+    relayerFee: bigint,
+    value: bigint,
+  ): Promise<ViemContractTransaction> {
+    return {
+      to: toAddress(gatewayAddress),
+      account: toAddress(sender),
+      value,
+      data: this.encodeFunctionData(
+        asAbi(IGATEWAY_V2_ABI),
+        "v2_registerToken",
+        [toAddress(token), BigInt(network), executionFee, relayerFee],
+      ),
+    };
+  }
+
+  async gatewayV2CreateAgent(
+    _provider: PublicClient,
+    gatewayAddress: string,
+    id: string,
+  ): Promise<ViemContractTransaction> {
+    return {
+      to: toAddress(gatewayAddress),
+      data: this.encodeFunctionData(asAbi(IGATEWAY_V2_ABI), "v2_createAgent", [
+        id as Hex,
+      ]),
+    };
+  }
+
+  async gatewayV2SendMessage(
+    _provider: PublicClient,
+    gatewayAddress: string,
+    sender: string,
+    xcm: Uint8Array,
+    assets: string[],
+    claimer: Uint8Array,
+    executionFee: bigint,
+    relayerFee: bigint,
+    value: bigint,
+  ): Promise<ViemContractTransaction> {
+    return {
+      to: toAddress(gatewayAddress),
+      account: toAddress(sender),
+      value,
+      data: this.encodeFunctionData(asAbi(IGATEWAY_V2_ABI), "v2_sendMessage", [
+        toBytesHex(xcm),
+        assets.map((asset) => asset as Hex),
+        toBytesHex(claimer),
+        executionFee,
+        relayerFee,
+      ]),
+    };
+  }
+
+  async l2AdapterSendEtherAndCall(
+    _provider: PublicClient,
+    adapterAddress: string,
+    sender: string,
+    params: DepositParamsStruct,
+    sendParams: SendParamsStruct,
+    recipient: string,
+    topic: string,
+    value?: bigint,
+  ): Promise<ViemContractTransaction> {
+    return {
+      to: toAddress(adapterAddress),
+      account: toAddress(sender),
+      value,
+      data: this.encodeFunctionData(
+        asAbi(SNOWBRIDGE_L2_ADAPTOR_ABI),
+        "sendEtherAndCall",
+        [
+          normalizeDepositParams(params),
+          normalizeSendParams(sendParams),
+          toAddress(recipient),
+          topic as Hex,
+        ],
+      ),
+    };
+  }
+
+  async l2AdapterSendTokenAndCall(
+    _provider: PublicClient,
+    adapterAddress: string,
+    sender: string,
+    params: DepositParamsStruct,
+    swapParams: SwapParamsStruct,
+    sendParams: SendParamsStruct,
+    recipient: string,
+    topic: string,
+  ): Promise<ViemContractTransaction> {
+    return {
+      to: toAddress(adapterAddress),
+      account: toAddress(sender),
+      data: this.encodeFunctionData(
+        asAbi(SNOWBRIDGE_L2_ADAPTOR_ABI),
+        "sendTokenAndCall",
+        [
+          normalizeDepositParams(params),
+          normalizeSwapParams(swapParams),
+          normalizeSendParams(sendParams),
+          toAddress(recipient),
+          topic as Hex,
+        ],
+      ),
+    };
+  }
+
+  async evmParachainTransferAssetsUsingTypeAndThenAddress(
+    _provider: PublicClient,
+    precompileAddress: string,
+    sourceAccount: string,
+    destination: [number, string[]],
+    assets: [string, bigint][],
+    assetsTransferType: number,
+    remoteFeesIdIndex: number,
+    feesTransferType: number,
+    customXcmHex: string,
+  ): Promise<ViemContractTransaction> {
+    return {
+      to: toAddress(precompileAddress),
+      account: toAddress(sourceAccount),
+      data: this.encodeFunctionData(
+        asAbi(MOONBEAM_PALLET_XCM_PRECOMPILE_ABI),
+        "transferAssetsUsingTypeAndThenAddress",
+        [
+          normalizeDestination(destination),
+          assets.map(([asset, amount]) => [toAddress(asset), amount]),
+          assetsTransferType,
+          remoteFeesIdIndex,
+          feesTransferType,
+          customXcmHex as Hex,
+        ],
+      ),
+    };
+  }
+
+  encodeFunctionData(
+    abi: Abi | readonly [string, ...string[]],
+    method: string,
+    args: readonly unknown[],
+  ): Hex {
+    return encodeFunctionData({
+      abi: asAbi(abi),
+      functionName: method,
+      args: [...args],
+    } as never);
+  }
+
+  decodeFunctionResult<T = unknown>(
+    abi: Abi | readonly [string, ...string[]],
+    method: string,
+    data: string,
+  ): T {
+    return decodeFunctionResult({
+      abi: asAbi(abi),
+      functionName: method,
+      data: data as Hex,
+    } as never) as T;
+  }
+
+  encodeNativeAsset(tokenAddress: string, amount: bigint): Hex {
+    return encodeAbiParameters(parseAbiParameters("uint8,address,uint128"), [
+      0,
+      toAddress(tokenAddress),
+      amount,
+    ]);
+  }
+
+  l1AdapterDepositNativeEther(
+    params: L1AdapterDepositParams,
+    recipient: string,
+    topic: string,
+  ): Hex {
+    return this.encodeFunctionData(
+      asAbi(SNOWBRIDGE_L1_ADAPTOR_ABI),
+      "depositNativeEther",
+      [normalizeDepositParams(params), toAddress(recipient), topic as Hex],
+    );
+  }
+
+  l1AdapterDepositToken(
+    params: L1AdapterDepositParams,
+    recipient: string,
+    topic: string,
+  ): Hex {
+    return this.encodeFunctionData(
+      asAbi(SNOWBRIDGE_L1_ADAPTOR_ABI),
+      "depositToken",
+      [normalizeDepositParams(params), toAddress(recipient), topic as Hex],
+    );
+  }
+
+  l1SwapRouterExactOutputSingle(
+    params: L1SwapRouterExactOutputSingleParams,
+  ): Hex {
+    return this.encodeFunctionData(
+      asAbi(SWAP_ROUTER_ABI),
+      "exactOutputSingle",
+      [
+        {
+          ...params,
+          tokenIn: toAddress(params.tokenIn),
+          tokenOut: toAddress(params.tokenOut),
+          recipient: toAddress(params.recipient),
+        },
+      ],
+    );
+  }
+
+  l1LegacySwapRouterExactOutputSingle(
+    params: L1LegacySwapRouterExactOutputSingleParams,
+  ): Hex {
+    return this.encodeFunctionData(
+      asAbi(SWAP_LEGACY_ROUTER_ABI),
+      "exactOutputSingle",
+      [
+        {
+          ...params,
+          tokenIn: toAddress(params.tokenIn),
+          tokenOut: toAddress(params.tokenOut),
+          recipient: toAddress(params.recipient),
+        },
+      ],
+    );
+  }
+
+  beneficiaryMultiAddress(beneficiary: string): MultiAddressStruct {
+    let kind: number;
+    if (/^0x[a-fA-F0-9]{40}$/.test(beneficiary)) {
+      kind = 2;
+    } else if (/^0x[a-fA-F0-9]{64}$/.test(beneficiary)) {
+      kind = 1;
+    } else {
+      throw new Error("Unknown Beneficiary address format.");
+    }
+    let data: Hex;
+    switch (kind) {
+      case 1:
+        data = encodeAbiParameters(parseAbiParameters("bytes32"), [
+          beneficiary as Hex,
+        ]);
+        break;
+      case 2:
+        data = encodeAbiParameters(parseAbiParameters("bytes20"), [
+          beneficiary as Hex,
+        ]);
+        break;
+      default:
+        throw new Error(`Unknown Beneficiary kind ${kind}.`);
+    }
+    return { kind, data };
+  }
+
+  async estimateGas(
+    provider: PublicClient,
+    tx: ViemContractTransaction,
+  ): Promise<bigint> {
+    return await provider.estimateGas(tx);
+  }
+
+  async getTransactionCount(
+    provider: PublicClient,
+    address: string,
+    blockTag: "latest" | "pending" = "latest",
+  ): Promise<number> {
+    return Number(
+      await provider.getTransactionCount({
+        address: toAddress(address),
+        blockTag,
+      }),
+    );
+  }
+
+  async getBalance(provider: PublicClient, address: string): Promise<bigint> {
+    return await provider.getBalance({ address: toAddress(address) });
+  }
+
+  async getFeeData(provider: PublicClient): Promise<FeeData> {
+    const gasPrice = await provider.getGasPrice();
+    try {
+      const fees = await provider.estimateFeesPerGas();
+      return {
+        gasPrice: fees.gasPrice ?? gasPrice,
+        maxFeePerGas: fees.maxFeePerGas ?? null,
+        maxPriorityFeePerGas: fees.maxPriorityFeePerGas ?? null,
+      };
+    } catch {
+      return {
+        gasPrice,
+        maxFeePerGas: null,
+        maxPriorityFeePerGas: null,
+      };
+    }
+  }
+
+  parseUnits(value: string, decimals: number): bigint {
+    return parseUnits(value, decimals);
+  }
+
+  async gatewayOperatingMode(
+    gateway: ViemContract & (IGatewayV1 | IGatewayV2),
+  ): Promise<bigint> {
+    return BigInt(await gateway.operatingMode());
+  }
+
+  async gatewayChannelOperatingModeOf(
+    gateway: ViemContract & IGatewayV1,
+    channelId: string,
+  ): Promise<bigint> {
+    return BigInt(await gateway.channelOperatingModeOf(channelId));
+  }
+
+  async isContractAddress(
+    provider: PublicClient,
+    address: string,
+  ): Promise<boolean> {
+    if (!/^0x[a-fA-F0-9]{40}$/.test(address)) {
+      return false;
+    }
+    try {
+      const code = await provider.getCode({ address: toAddress(address) });
+      return code !== undefined && code !== "0x";
+    } catch {
+      return false;
+    }
+  }
+
+  scanGatewayV1OutboundMessageAccepted(
+    receipt: TransactionReceipt,
+  ): GatewayV1OutboundMessageAccepted | null {
+    for (const log of receipt.logs as Log[]) {
+      try {
+        const event = decodeEventLog({
+          abi: asAbi(IGATEWAY_V1_ABI),
+          topics: log.topics,
+          data: log.data,
+        });
+        if (event.eventName === "OutboundMessageAccepted") {
+          const args = event.args as unknown as readonly unknown[] | undefined;
+          if (!args) {
+            continue;
+          }
+          return {
+            channelId: String(args[0]),
+            nonce: BigInt(args[1] as bigint),
+            messageId: String(args[2]),
+            blockHash: receipt.blockHash,
+            blockNumber: Number(receipt.blockNumber),
+            txHash: receipt.transactionHash,
+            txIndex: Number(receipt.transactionIndex),
+          };
+        }
+      } catch {}
+    }
+    return null;
+  }
+
+  scanGatewayV2OutboundMessageAccepted(
+    receipt: TransactionReceipt,
+  ): GatewayV2OutboundMessageAccepted | null {
+    for (const log of receipt.logs as Log[]) {
+      try {
+        const event = decodeEventLog({
+          abi: asAbi(IGATEWAY_V2_ABI),
+          topics: log.topics,
+          data: log.data,
+        });
+        if (event.eventName === "OutboundMessageAccepted") {
+          const args = event.args as unknown as
+            | {
+                nonce: bigint;
+                payload: {
+                  origin: Address;
+                  assets: { kind: number; data: Hex }[];
+                  xcm: { kind: number; data: Hex };
+                  claimer: Hex;
+                  value: bigint;
+                  executionFee: bigint;
+                  relayerFee: bigint;
+                };
+              }
+            | undefined;
+          if (!args) {
+            continue;
+          }
+          return {
+            nonce: BigInt(args.nonce),
+            payload: {
+              origin: args.payload.origin,
+              assets: args.payload.assets.map((asset) => [
+                Number(asset.kind),
+                asset.data,
+              ]),
+              xcm: [Number(args.payload.xcm.kind), args.payload.xcm.data],
+              claimer: args.payload.claimer,
+              value: BigInt(args.payload.value),
+              executionFee: BigInt(args.payload.executionFee),
+              relayerFee: BigInt(args.payload.relayerFee),
+            },
+            blockHash: receipt.blockHash,
+            blockNumber: Number(receipt.blockNumber),
+            txHash: receipt.transactionHash,
+            txIndex: Number(receipt.transactionIndex),
+          };
+        }
+      } catch {}
+    }
+    return null;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "target": "es2021",
+    "module": "commonjs",
+    "strict": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "declarationMap": true,
+    "baseUrl": ".",
+    "rootDir": "src",
+    "noEmitOnError": true,
+    "skipLibCheck": true,
+    "allowJs": true
+  },
+  "ts-node": {
+    "require": ["tsconfig-paths/register"]
+  },
+  "exclude": ["node_modules", "dist"],
+  "include": ["src/**/*.ts"],
+  "references": []
+}