@relay-protocol/settlement-sdk 0.0.64

package/dist/messages/v2.1/depository-withdrawal.js

@@ -0,0 +1,661 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDecodedWithdrawalRecipient = exports.getDecodedWithdrawalAmount = exports.getDecodedWithdrawalCurrency = exports.getDecodedWithdrawalId = exports.decodeWithdrawal = exports.encodeWithdrawal = exports.getDepositoryWithdrawalMessageId = exports.DepositoryWithdrawalStatus = void 0;
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const anchor_1 = require("@coral-xyz/anchor");
+const bcs_1 = require("@mysten/sui/bcs");
+const web3_js_1 = require("@solana/web3.js");
+const js_sha256_1 = require("js-sha256");
+const tronweb = __importStar(require("tronweb"));
+const bitcoin = __importStar(require("bitcoinjs-lib"));
+const viem_1 = require("viem");
+const utils_1 = require("../../utils");
+const RelayDepositoryIdl_1 = require("../common/solana-vm/idls/RelayDepositoryIdl");
+var DepositoryWithdrawalStatus;
+(function (DepositoryWithdrawalStatus) {
+    DepositoryWithdrawalStatus[DepositoryWithdrawalStatus["PENDING"] = 0] = "PENDING";
+    DepositoryWithdrawalStatus[DepositoryWithdrawalStatus["EXECUTED"] = 1] = "EXECUTED";
+    DepositoryWithdrawalStatus[DepositoryWithdrawalStatus["EXPIRED"] = 2] = "EXPIRED";
+})(DepositoryWithdrawalStatus || (exports.DepositoryWithdrawalStatus = DepositoryWithdrawalStatus = {}));
+const getDepositoryWithdrawalMessageId = (message, chainsConfig) => {
+    const vmType = (chainId) => (0, utils_1.getChainVmType)(chainId, chainsConfig);
+    return (0, viem_1.hashStruct)({
+        types: {
+            DepositoryWithdrawal: [
+                { name: "data", type: "Data" },
+                { name: "result", type: "Result" },
+            ],
+            Data: [
+                { name: "chainId", type: "string" },
+                { name: "withdrawal", type: "bytes" },
+            ],
+            Result: [
+                { name: "withdrawalId", type: "bytes32" },
+                { name: "depository", type: "bytes" },
+                { name: "status", type: "uint8" },
+            ],
+        },
+        primaryType: "DepositoryWithdrawal",
+        data: {
+            data: {
+                chainId: message.data.chainId,
+                withdrawal: (0, utils_1.encodeBytes)(message.data.withdrawal),
+            },
+            result: {
+                withdrawalId: (0, viem_1.bytesToHex)((0, utils_1.encodeBytes)(message.result.withdrawalId)),
+                depository: (0, utils_1.encodeAddress)(message.result.depository, vmType(message.data.chainId)),
+                status: message.result.status,
+            },
+        },
+    });
+};
+exports.getDepositoryWithdrawalMessageId = getDepositoryWithdrawalMessageId;
+const encodeWithdrawal = (decodedWithdrawal) => {
+    switch (decodedWithdrawal.vmType) {
+        case "ethereum-vm": {
+            return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                "((address to, bytes data, uint256 value, bool allowFailure)[] calls, uint256 nonce, uint256 expiration)",
+            ]), [
+                {
+                    calls: decodedWithdrawal.withdrawal.calls.map((call) => ({
+                        to: call.to,
+                        data: call.data,
+                        value: BigInt(call.value),
+                        allowFailure: call.allowFailure,
+                    })),
+                    nonce: BigInt(decodedWithdrawal.withdrawal.nonce),
+                    expiration: BigInt(decodedWithdrawal.withdrawal.expiration),
+                },
+            ]);
+        }
+        case "tron-vm": {
+            const callsArray = decodedWithdrawal.withdrawal.calls.map((c) => [
+                c.to.replace(tronweb.utils.address.ADDRESS_PREFIX_REGEX, "0x"),
+                c.data,
+                BigInt(c.value),
+                Boolean(c.allowFailure),
+            ]);
+            const types = [
+                "tuple(tuple(address,bytes,uint256,bool)[],uint256,uint256)",
+            ];
+            const values = [
+                [
+                    callsArray,
+                    BigInt(decodedWithdrawal.withdrawal.nonce),
+                    BigInt(decodedWithdrawal.withdrawal.expiration),
+                ],
+            ];
+            return tronweb.utils.abi.encodeParams(types, values);
+        }
+        case "solana-vm": {
+            const coder = new anchor_1.BorshCoder(RelayDepositoryIdl_1.RelayDepositoryIdl);
+            return ("0x" +
+                coder.types
+                    .encode("TransferRequest", {
+                    domain: Buffer.from(decodedWithdrawal.withdrawal.domain.slice(2), "hex"),
+                    recipient: new web3_js_1.PublicKey(decodedWithdrawal.withdrawal.recipient),
+                    token: decodedWithdrawal.withdrawal.token ===
+                        web3_js_1.SystemProgram.programId.toBase58()
+                        ? null
+                        : new web3_js_1.PublicKey(decodedWithdrawal.withdrawal.token),
+                    amount: new anchor.BN(decodedWithdrawal.withdrawal.amount),
+                    nonce: new anchor.BN(decodedWithdrawal.withdrawal.nonce),
+                    expiration: new anchor.BN(decodedWithdrawal.withdrawal.expiration),
+                    vault_address: new web3_js_1.PublicKey(decodedWithdrawal.withdrawal.vaultAddress),
+                })
+                    .toString("hex"));
+        }
+        case "sui-vm": {
+            return ("0x" +
+                Buffer.from(bcs_1.bcs
+                    .struct("TransferRequest", {
+                    recipient: bcs_1.bcs.Address,
+                    amount: bcs_1.bcs.u64(),
+                    coin_type: bcs_1.bcs.struct("TypeName", {
+                        name: bcs_1.bcs.string(),
+                    }),
+                    nonce: bcs_1.bcs.u64(),
+                    expiration: bcs_1.bcs.u64(),
+                })
+                    .serialize({
+                    recipient: decodedWithdrawal.withdrawal.recipient,
+                    amount: BigInt(decodedWithdrawal.withdrawal.amount),
+                    coin_type: {
+                        name: decodedWithdrawal.withdrawal.coinType,
+                    },
+                    nonce: BigInt(decodedWithdrawal.withdrawal.nonce),
+                    expiration: BigInt(decodedWithdrawal.withdrawal.expiration),
+                })
+                    .toBytes()).toString("hex"));
+        }
+        case "bitcoin-vm": {
+            return "0x" + decodedWithdrawal.withdrawal.psbt;
+        }
+        case "hyperliquid-vm": {
+            const { txType, parameters } = decodedWithdrawal.withdrawal;
+            let encodedParameters;
+            switch (parameters.type) {
+                case "UsdSend": {
+                    encodedParameters = (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                        "(string hyperliquidChain, string destination, string amount, uint64 time)",
+                    ]), [
+                        {
+                            hyperliquidChain: parameters.hyperliquidChain,
+                            destination: parameters.destination,
+                            amount: parameters.amount,
+                            time: BigInt(parameters.time),
+                        },
+                    ]);
+                    break;
+                }
+                case "SendAsset": {
+                    encodedParameters = (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                        "(string hyperliquidChain, string destination, string sourceDex, string destinationDex, string token, string amount, string fromSubAccount, uint64 nonce)",
+                    ]), [
+                        {
+                            hyperliquidChain: parameters.hyperliquidChain,
+                            destination: parameters.destination,
+                            sourceDex: parameters.sourceDex,
+                            destinationDex: parameters.destinationDex,
+                            token: parameters.token,
+                            amount: parameters.amount,
+                            fromSubAccount: parameters.fromSubAccount,
+                            nonce: BigInt(parameters.nonce),
+                        },
+                    ]);
+                    break;
+                }
+                default: {
+                    throw new Error(`Unsupported Hyperliquid transaction type ${parameters.type}`);
+                }
+            }
+            return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)(["(uint8 txType, bytes parameters)"]), [
+                {
+                    txType,
+                    parameters: encodedParameters,
+                },
+            ]);
+        }
+        default:
+            throw new Error("Unsupported vm type");
+    }
+};
+exports.encodeWithdrawal = encodeWithdrawal;
+const decodeWithdrawal = (encodedWithdrawal, vmType) => {
+    switch (vmType) {
+        case "ethereum-vm": {
+            const result = (0, viem_1.decodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                "((address to, bytes data, uint256 value, bool allowFailure)[] calls, uint256 nonce, uint256 expiration)",
+            ]), encodedWithdrawal);
+            return {
+                vmType: "ethereum-vm",
+                withdrawal: {
+                    calls: result[0].calls.map((call) => ({
+                        to: call.to.toLowerCase(),
+                        data: call.data.toLowerCase(),
+                        value: call.value.toString(),
+                        allowFailure: call.allowFailure,
+                    })),
+                    nonce: result[0].nonce.toString(),
+                    expiration: Number(result[0].expiration.toString()),
+                },
+            };
+        }
+        case "tron-vm": {
+            const types = [
+                "tuple(tuple(address,bytes,uint256,bool)[],uint256,uint256)",
+            ];
+            const decoded = tronweb.utils.abi.decodeParams([], types, encodedWithdrawal);
+            const [argTuple] = decoded;
+            const [decodedCalls, decodedNonce, decodedExpiration] = argTuple;
+            return {
+                vmType: "tron-vm",
+                withdrawal: {
+                    calls: decodedCalls.map(([to, data, value, allowFailure]) => ({
+                        to: to
+                            .toLowerCase()
+                            .replace("0x", tronweb.utils.address.ADDRESS_PREFIX),
+                        data: data.toLowerCase(),
+                        value: BigInt(value).toString(),
+                        allowFailure: Boolean(allowFailure),
+                    })),
+                    nonce: BigInt(decodedNonce).toString(),
+                    expiration: Number(BigInt(decodedExpiration).toString()),
+                },
+            };
+        }
+        case "solana-vm": {
+            const buffer = Buffer.from(encodedWithdrawal.substring(2), "hex");
+            const coder = new anchor_1.BorshCoder(RelayDepositoryIdl_1.RelayDepositoryIdl);
+            const request = coder.types.decode("TransferRequest", buffer);
+            return {
+                vmType: "solana-vm",
+                withdrawal: {
+                    domain: "0x" + Buffer.from(request.domain).toString("hex"),
+                    recipient: request.recipient.toBase58(),
+                    token: request.token
+                        ? request.token.toBase58()
+                        : web3_js_1.SystemProgram.programId.toBase58(),
+                    amount: request.amount.toString(),
+                    nonce: request.nonce.toString(),
+                    expiration: request.expiration.toNumber(),
+                    vaultAddress: request.vault_address.toBase58(),
+                },
+            };
+        }
+        case "sui-vm": {
+            const buffer = Uint8Array.from(Buffer.from(encodedWithdrawal.substring(2), "hex"));
+            const request = bcs_1.bcs
+                .struct("TransferRequest", {
+                recipient: bcs_1.bcs.Address,
+                amount: bcs_1.bcs.u64(),
+                coin_type: bcs_1.bcs.struct("TypeName", {
+                    name: bcs_1.bcs.string(),
+                }),
+                nonce: bcs_1.bcs.u64(),
+                expiration: bcs_1.bcs.u64(),
+            })
+                .parse(buffer);
+            return {
+                vmType: "sui-vm",
+                withdrawal: {
+                    recipient: request.recipient,
+                    coinType: request.coin_type.name,
+                    amount: request.amount.toString(),
+                    nonce: request.nonce.toString(),
+                    expiration: Number(request.expiration.toString()),
+                },
+            };
+        }
+        case "bitcoin-vm": {
+            return {
+                vmType: "bitcoin-vm",
+                withdrawal: {
+                    psbt: encodedWithdrawal.slice(2),
+                },
+            };
+        }
+        case "hyperliquid-vm": {
+            const result = (0, viem_1.decodeAbiParameters)((0, viem_1.parseAbiParameters)(["(uint8 txType, bytes parameters)"]), encodedWithdrawal);
+            const { txType, parameters } = result[0];
+            switch (txType) {
+                case 0: {
+                    // UsdSend
+                    const paramResult = (0, viem_1.decodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                        "(string hyperliquidChain, string destination, string amount, uint64 time)",
+                    ]), parameters);
+                    const { hyperliquidChain, destination, amount, time } = paramResult[0];
+                    return {
+                        vmType: "hyperliquid-vm",
+                        withdrawal: {
+                            txType: Number(txType),
+                            parameters: {
+                                type: "UsdSend",
+                                hyperliquidChain,
+                                destination,
+                                amount,
+                                time: time.toString(),
+                            },
+                        },
+                    };
+                }
+                case 1: {
+                    // SendAsset
+                    const paramResult = (0, viem_1.decodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                        "(string hyperliquidChain, string destination, string sourceDex, string destinationDex, string token, string amount, string fromSubAccount, uint64 nonce)",
+                    ]), parameters);
+                    const { hyperliquidChain, destination, sourceDex, destinationDex, token, amount, fromSubAccount, nonce, } = paramResult[0];
+                    return {
+                        vmType: "hyperliquid-vm",
+                        withdrawal: {
+                            txType: Number(txType),
+                            parameters: {
+                                type: "SendAsset",
+                                hyperliquidChain,
+                                destination,
+                                sourceDex,
+                                destinationDex,
+                                token,
+                                amount,
+                                fromSubAccount,
+                                nonce: nonce.toString(),
+                            },
+                        },
+                    };
+                }
+                default: {
+                    throw new Error(`Unsupported Hyperliquid transaction type: ${txType}`);
+                }
+            }
+        }
+        default:
+            throw new Error("Unsupported vm type");
+    }
+};
+exports.decodeWithdrawal = decodeWithdrawal;
+const getDecodedWithdrawalId = (decodedWithdrawal) => {
+    switch (decodedWithdrawal.vmType) {
+        case "ethereum-vm": {
+            return (0, viem_1.hashStruct)({
+                types: {
+                    CallRequest: [
+                        { name: "calls", type: "Call[]" },
+                        { name: "nonce", type: "uint256" },
+                        { name: "expiration", type: "uint256" },
+                    ],
+                    Call: [
+                        { name: "to", type: "address" },
+                        { name: "data", type: "bytes" },
+                        { name: "value", type: "uint256" },
+                        { name: "allowFailure", type: "bool" },
+                    ],
+                },
+                primaryType: "CallRequest",
+                data: {
+                    calls: decodedWithdrawal.withdrawal.calls,
+                    nonce: decodedWithdrawal.withdrawal.nonce,
+                    expiration: decodedWithdrawal.withdrawal.expiration,
+                },
+            });
+        }
+        case "tron-vm": {
+            return tronweb.utils._TypedDataEncoder.hashStruct("CallRequest", {
+                CallRequest: [
+                    { name: "calls", type: "Call[]" },
+                    { name: "nonce", type: "uint256" },
+                    { name: "expiration", type: "uint256" },
+                ],
+                Call: [
+                    { name: "to", type: "address" },
+                    { name: "data", type: "bytes" },
+                    { name: "value", type: "uint256" },
+                    { name: "allowFailure", type: "bool" },
+                ],
+            }, {
+                calls: decodedWithdrawal.withdrawal.calls,
+                nonce: decodedWithdrawal.withdrawal.nonce,
+                expiration: decodedWithdrawal.withdrawal.expiration,
+            });
+        }
+        case "solana-vm": {
+            const coder = new anchor_1.BorshCoder(RelayDepositoryIdl_1.RelayDepositoryIdl);
+            const encodedWithdrawal = coder.types.encode("TransferRequest", {
+                domain: Buffer.from(decodedWithdrawal.withdrawal.domain.slice(2), "hex"),
+                recipient: new web3_js_1.PublicKey(decodedWithdrawal.withdrawal.recipient),
+                token: decodedWithdrawal.withdrawal.token ===
+                    web3_js_1.SystemProgram.programId.toBase58()
+                    ? null
+                    : new web3_js_1.PublicKey(decodedWithdrawal.withdrawal.token),
+                amount: new anchor.BN(decodedWithdrawal.withdrawal.amount),
+                nonce: new anchor.BN(decodedWithdrawal.withdrawal.nonce),
+                expiration: new anchor.BN(decodedWithdrawal.withdrawal.expiration),
+                vault_address: new web3_js_1.PublicKey(decodedWithdrawal.withdrawal.vaultAddress),
+            });
+            return ("0x" +
+                Buffer.from(js_sha256_1.sha256.create().update(encodedWithdrawal).array()).toString("hex"));
+        }
+        case "sui-vm": {
+            const encodedWithdrawal = "0x" +
+                Buffer.from(bcs_1.bcs
+                    .struct("TransferRequest", {
+                    recipient: bcs_1.bcs.Address,
+                    amount: bcs_1.bcs.u64(),
+                    coin_type: bcs_1.bcs.struct("TypeName", {
+                        name: bcs_1.bcs.string(),
+                    }),
+                    nonce: bcs_1.bcs.u64(),
+                    expiration: bcs_1.bcs.u64(),
+                })
+                    .serialize({
+                    recipient: decodedWithdrawal.withdrawal.recipient,
+                    amount: BigInt(decodedWithdrawal.withdrawal.amount),
+                    coin_type: {
+                        name: decodedWithdrawal.withdrawal.coinType,
+                    },
+                    nonce: BigInt(decodedWithdrawal.withdrawal.nonce),
+                    expiration: BigInt(decodedWithdrawal.withdrawal.expiration),
+                })
+                    .toBytes()).toString("hex");
+            return "0x" + js_sha256_1.sha256.create().update(encodedWithdrawal).hex();
+        }
+        case "bitcoin-vm": {
+            const encodedWithdrawal = "0x" + decodedWithdrawal.withdrawal.psbt;
+            return "0x" + js_sha256_1.sha256.create().update(encodedWithdrawal).hex();
+        }
+        case "hyperliquid-vm": {
+            const { parameters } = decodedWithdrawal.withdrawal;
+            switch (parameters.type) {
+                case "UsdSend": {
+                    return (0, viem_1.hashStruct)({
+                        types: {
+                            "HyperliquidTransaction:UsdSend": [
+                                { name: "hyperliquidChain", type: "string" },
+                                { name: "destination", type: "string" },
+                                { name: "amount", type: "string" },
+                                { name: "time", type: "uint64" },
+                            ],
+                        },
+                        primaryType: "HyperliquidTransaction:UsdSend",
+                        data: {
+                            hyperliquidChain: parameters.hyperliquidChain,
+                            destination: parameters.destination,
+                            amount: parameters.amount,
+                            time: parameters.time,
+                        },
+                    });
+                }
+                case "SendAsset": {
+                    return (0, viem_1.hashStruct)({
+                        types: {
+                            "HyperliquidTransaction:SendAsset": [
+                                { name: "hyperliquidChain", type: "string" },
+                                { name: "destination", type: "string" },
+                                { name: "sourceDex", type: "string" },
+                                { name: "destinationDex", type: "string" },
+                                { name: "token", type: "string" },
+                                { name: "amount", type: "string" },
+                                { name: "fromSubAccount", type: "string" },
+                                { name: "nonce", type: "uint64" },
+                            ],
+                        },
+                        primaryType: "HyperliquidTransaction:SendAsset",
+                        data: {
+                            hyperliquidChain: parameters.hyperliquidChain,
+                            destination: parameters.destination,
+                            sourceDex: parameters.sourceDex,
+                            destinationDex: parameters.destinationDex,
+                            token: parameters.token,
+                            amount: parameters.amount,
+                            fromSubAccount: parameters.fromSubAccount,
+                            nonce: parameters.nonce,
+                        },
+                    });
+                }
+                default: {
+                    throw new Error(`Unsupported Hyperliquid transaction type ${parameters.type}`);
+                }
+            }
+        }
+        default:
+            throw new Error("Unsupported vm type");
+    }
+};
+exports.getDecodedWithdrawalId = getDecodedWithdrawalId;
+const getDecodedWithdrawalCurrency = (decodedWithdrawal) => {
+    switch (decodedWithdrawal.vmType) {
+        case "bitcoin-vm": {
+            return (0, utils_1.getVmTypeNativeCurrency)(decodedWithdrawal.vmType);
+        }
+        case "ethereum-vm": {
+            const firstCall = decodedWithdrawal.withdrawal.calls[0];
+            return firstCall.data === "0x"
+                ? (0, utils_1.getVmTypeNativeCurrency)(decodedWithdrawal.vmType)
+                : firstCall.to;
+        }
+        case "tron-vm": {
+            const firstCall = decodedWithdrawal.withdrawal.calls[0];
+            return firstCall.data === "0x"
+                ? (0, utils_1.getVmTypeNativeCurrency)(decodedWithdrawal.vmType)
+                : firstCall.to;
+        }
+        case "solana-vm": {
+            return decodedWithdrawal.withdrawal.token;
+        }
+        case "sui-vm": {
+            return decodedWithdrawal.withdrawal.coinType;
+        }
+        case "hyperliquid-vm": {
+            const { parameters } = decodedWithdrawal.withdrawal;
+            switch (parameters.type) {
+                case "UsdSend": {
+                    return (0, utils_1.getVmTypeNativeCurrency)(decodedWithdrawal.vmType);
+                }
+                case "SendAsset": {
+                    const SPOT_USDC = "0x6d1e7cde53ba9467b783cb7c530ce054";
+                    const tokenAddress = parameters.token.split(":")[1].toLowerCase();
+                    const tokenDex = parameters.sourceDex;
+                    if (tokenDex === "" && tokenAddress !== SPOT_USDC) {
+                        throw new Error("Only USDC is supported as a Perps token");
+                    }
+                    return tokenDex === "spot"
+                        ? tokenAddress.toLowerCase()
+                        : tokenDex === ""
+                            ? (0, utils_1.getVmTypeNativeCurrency)(decodedWithdrawal.vmType)
+                            : tokenAddress.toLowerCase() +
+                                Buffer.from(tokenDex, "ascii").toString("hex");
+                }
+                default:
+                    throw new Error(`Unsupported Hyperliquid transaction type ${parameters.type}`);
+            }
+        }
+    }
+};
+exports.getDecodedWithdrawalCurrency = getDecodedWithdrawalCurrency;
+const decodeERC20TransferParams = (data) => {
+    // ERC20 / TRC20 `transfer(address,uint256)` selector is 0xa9059cbb
+    const TRANSFER_SELECTOR = "0xa9059cbb";
+    if (data.toLowerCase().startsWith(TRANSFER_SELECTOR.toLowerCase())) {
+        const paramsData = ("0x" + data.slice(TRANSFER_SELECTOR.length));
+        const params = (0, viem_1.decodeAbiParameters)((0, viem_1.parseAbiParameters)(["address", "uint256"]), paramsData);
+        return params;
+    }
+    else {
+        throw new Error(`Unsupported function call data: ${data}`);
+    }
+};
+const getDecodedWithdrawalAmount = (decodedWithdrawal) => {
+    switch (decodedWithdrawal.vmType) {
+        case "ethereum-vm": {
+            const firstCall = decodedWithdrawal.withdrawal.calls[0];
+            if (firstCall.data === "0x") {
+                return firstCall.value;
+            }
+            else {
+                const [, amount] = decodeERC20TransferParams(firstCall.data);
+                return amount.toString();
+            }
+        }
+        case "tron-vm": {
+            const firstCall = decodedWithdrawal.withdrawal.calls[0];
+            if (firstCall.data === "0x") {
+                return firstCall.value;
+            }
+            else {
+                const [, amount] = decodeERC20TransferParams(firstCall.data);
+                return amount.toString();
+            }
+        }
+        case "solana-vm": {
+            return decodedWithdrawal.withdrawal.amount;
+        }
+        case "sui-vm": {
+            return decodedWithdrawal.withdrawal.amount;
+        }
+        case "bitcoin-vm": {
+            const psbt = bitcoin.Psbt.fromHex(decodedWithdrawal.withdrawal.psbt);
+            return psbt.txOutputs[0].value.toString();
+        }
+        case "hyperliquid-vm": {
+            // The assumption here is that the amount is always encoded with the full decimals of the currency
+            const decimals = decodedWithdrawal.withdrawal.parameters.amount.split(".")[1].length;
+            return (0, viem_1.parseUnits)(decodedWithdrawal.withdrawal.parameters.amount, decimals).toString();
+        }
+        default:
+            throw new Error("Unsupported vm type");
+    }
+};
+exports.getDecodedWithdrawalAmount = getDecodedWithdrawalAmount;
+const getDecodedWithdrawalRecipient = (decodedWithdrawal) => {
+    switch (decodedWithdrawal.vmType) {
+        case "ethereum-vm": {
+            const firstCall = decodedWithdrawal.withdrawal.calls[0];
+            if (firstCall.data === "0x") {
+                return firstCall.to;
+            }
+            else {
+                const [to] = decodeERC20TransferParams(firstCall.data);
+                return to;
+            }
+        }
+        case "tron-vm": {
+            const firstCall = decodedWithdrawal.withdrawal.calls[0];
+            if (firstCall.data === "0x") {
+                return firstCall.to;
+            }
+            else {
+                const [to] = decodeERC20TransferParams(firstCall.data);
+                return to;
+            }
+        }
+        case "solana-vm": {
+            return decodedWithdrawal.withdrawal.recipient;
+        }
+        case "sui-vm": {
+            return decodedWithdrawal.withdrawal.recipient;
+        }
+        case "bitcoin-vm": {
+            const psbt = bitcoin.Psbt.fromHex(decodedWithdrawal.withdrawal.psbt);
+            const firstOutput = psbt.txOutputs[0];
+            return bitcoin.address.fromOutputScript(firstOutput.script);
+        }
+        case "hyperliquid-vm": {
+            return decodedWithdrawal.withdrawal.parameters.destination;
+        }
+        default:
+            throw new Error("Unsupported vm type");
+    }
+};
+exports.getDecodedWithdrawalRecipient = getDecodedWithdrawalRecipient;

package/dist/messages/v2.1/solver-fill.d.ts

@@ -0,0 +1,26 @@
+import { Order } from "../../order";
+import { ChainIdToVmType } from "../../utils";
+export declare enum SolverFillStatus {
+    FAILED = 0,
+    SUCCESSFUL = 1
+}
+export type SolverFillMessage = {
+    data: {
+        order: Order;
+        orderSignature: string;
+        inputs: {
+            transactionId: string;
+            onchainId: string;
+            inputIndex: number;
+        }[];
+        fill: {
+            transactionId: string;
+        };
+    };
+    result: {
+        orderId: string;
+        status: SolverFillStatus;
+        totalWeightedInputPaymentBpsDiff: string;
+    };
+};
+export declare const getSolverFillMessageId: (message: SolverFillMessage, chainsConfig: ChainIdToVmType) => `0x${string}`;