@relay-protocol/settlement-sdk 0.0.64

package/dist/messages/v2.1/solver-fill.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSolverFillMessageId = exports.SolverFillStatus = void 0;
+const viem_1 = require("viem");
+const order_1 = require("../../order");
+const utils_1 = require("../../utils");
+var SolverFillStatus;
+(function (SolverFillStatus) {
+    SolverFillStatus[SolverFillStatus["FAILED"] = 0] = "FAILED";
+    SolverFillStatus[SolverFillStatus["SUCCESSFUL"] = 1] = "SUCCESSFUL";
+})(SolverFillStatus || (exports.SolverFillStatus = SolverFillStatus = {}));
+const getSolverFillMessageId = (message, chainsConfig) => {
+    const vmType = (chainId) => (0, utils_1.getChainVmType)(chainId, chainsConfig);
+    return (0, viem_1.hashStruct)({
+        types: {
+            SolverFill: [
+                { name: "data", type: "Data" },
+                { name: "result", type: "Result" },
+            ],
+            Data: [
+                { name: "order", type: "Order" },
+                { name: "orderSignature", type: "bytes" },
+                { name: "inputs", type: "InputEntry[]" },
+                { name: "fill", type: "FillEntry" },
+            ],
+            Result: [
+                { name: "orderId", type: "bytes32" },
+                { name: "status", type: "uint8" },
+                { name: "totalWeightedInputPaymentBpsDiff", type: "int256" },
+            ],
+            ...order_1.ORDER_EIP712_TYPES,
+            InputEntry: [
+                { name: "transactionId", type: "bytes" },
+                { name: "onchainId", type: "bytes32" },
+                { name: "inputIndex", type: "uint32" },
+            ],
+            FillEntry: [{ name: "transactionId", type: "bytes" }],
+        },
+        primaryType: "SolverFill",
+        data: {
+            data: {
+                order: (0, order_1.normalizeOrder)(message.data.order, chainsConfig),
+                orderSignature: (0, utils_1.encodeBytes)(message.data.orderSignature),
+                inputs: message.data.inputs.map((input) => ({
+                    transactionId: (0, utils_1.encodeTransactionId)(input.transactionId, vmType(message.data.order.inputs[input.inputIndex].payment.chainId)),
+                    onchainId: (0, viem_1.bytesToHex)((0, utils_1.encodeBytes)(input.onchainId)),
+                    inputIndex: input.inputIndex,
+                })),
+                fill: {
+                    transactionId: (0, utils_1.encodeTransactionId)(message.data.fill.transactionId, vmType(message.data.order.output.chainId)),
+                },
+            },
+            result: {
+                orderId: (0, viem_1.bytesToHex)((0, utils_1.encodeBytes)(message.result.orderId)),
+                status: message.result.status,
+                totalWeightedInputPaymentBpsDiff: message.result.totalWeightedInputPaymentBpsDiff,
+            },
+        },
+    });
+};
+exports.getSolverFillMessageId = getSolverFillMessageId;

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

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

package/dist/messages/v2.1/solver-refund.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSolverRefundMessageId = exports.SolverRefundStatus = void 0;
+const viem_1 = require("viem");
+const order_1 = require("../../order");
+const utils_1 = require("../../utils");
+var SolverRefundStatus;
+(function (SolverRefundStatus) {
+    SolverRefundStatus[SolverRefundStatus["FAILED"] = 0] = "FAILED";
+    SolverRefundStatus[SolverRefundStatus["SUCCESSFUL"] = 1] = "SUCCESSFUL";
+})(SolverRefundStatus || (exports.SolverRefundStatus = SolverRefundStatus = {}));
+const getSolverRefundMessageId = (message, chainsConfig) => {
+    const vmType = (chainId) => (0, utils_1.getChainVmType)(chainId, chainsConfig);
+    return (0, viem_1.hashStruct)({
+        types: {
+            SolverRefund: [
+                { name: "data", type: "Data" },
+                { name: "result", type: "Result" },
+            ],
+            Data: [
+                { name: "order", type: "Order" },
+                { name: "orderSignature", type: "bytes" },
+                { name: "inputs", type: "InputEntry[]" },
+                { name: "refunds", type: "RefundEntry[]" },
+            ],
+            Result: [
+                { name: "orderId", type: "bytes32" },
+                { name: "status", type: "uint8" },
+                { name: "totalWeightedInputPaymentBpsDiff", type: "int256" },
+            ],
+            ...order_1.ORDER_EIP712_TYPES,
+            InputEntry: [
+                { name: "transactionId", type: "bytes" },
+                { name: "onchainId", type: "bytes32" },
+                { name: "inputIndex", type: "uint32" },
+            ],
+            RefundEntry: [
+                { name: "transactionId", type: "bytes" },
+                { name: "inputIndex", type: "uint32" },
+                { name: "refundIndex", type: "uint32" },
+            ],
+        },
+        primaryType: "SolverRefund",
+        data: {
+            data: {
+                order: (0, order_1.normalizeOrder)(message.data.order, chainsConfig),
+                orderSignature: (0, utils_1.encodeBytes)(message.data.orderSignature),
+                inputs: message.data.inputs.map((input) => ({
+                    transactionId: (0, utils_1.encodeTransactionId)(input.transactionId, vmType(message.data.order.inputs[input.inputIndex].payment.chainId)),
+                    onchainId: (0, viem_1.bytesToHex)((0, utils_1.encodeBytes)(input.onchainId)),
+                    inputIndex: input.inputIndex,
+                })),
+                refunds: message.data.refunds.map((refund) => ({
+                    transactionId: (0, utils_1.encodeTransactionId)(refund.transactionId, vmType(message.data.order.inputs[refund.inputIndex].refunds[refund.refundIndex].chainId)),
+                    inputIndex: refund.inputIndex,
+                    refundIndex: refund.refundIndex,
+                })),
+            },
+            result: {
+                orderId: (0, viem_1.bytesToHex)((0, utils_1.encodeBytes)(message.result.orderId)),
+                status: message.result.status,
+                totalWeightedInputPaymentBpsDiff: message.result.totalWeightedInputPaymentBpsDiff,
+            },
+        },
+    });
+};
+exports.getSolverRefundMessageId = getSolverRefundMessageId;

package/dist/messages/v2.2/execution.d.ts

@@ -0,0 +1,48 @@
+import { VmType } from "../../utils";
+export declare enum ActionType {
+    MINT = 0,
+    BURN = 1,
+    TRANSFER = 2
+}
+export type ExecutionMessageMetadata = {
+    hubTokenId: bigint;
+    origin: {
+        address: string;
+        chainId: bigint;
+        family: VmType;
+    };
+    oracleChainId: string;
+    oracleContract: `0x${string}`;
+};
+export type ExecutionMessage = {
+    idempotencyKey: string;
+    actions: string[];
+    metadata?: ExecutionMessageMetadata[];
+};
+export type ExecutionMetadata = Omit<ExecutionMessageMetadata, "oracleContract" | "oracleChainId">;
+export declare const getExecutionMessageId: (message: ExecutionMessage) => `0x${string}`;
+export type DecodedAction = {
+    type: ActionType.MINT;
+    data: {
+        hubToAddress: string;
+        hubTokenId: bigint;
+        amount: string;
+    };
+} | {
+    type: ActionType.BURN;
+    data: {
+        hubFromAddress: string;
+        hubTokenId: bigint;
+        amount: string;
+    };
+} | {
+    type: ActionType.TRANSFER;
+    data: {
+        hubFromAddress: string;
+        hubToAddress: string;
+        hubTokenId: bigint;
+        amount: string;
+    };
+};
+export declare const encodeAction: (action: DecodedAction) => string;
+export declare const decodeAction: (action: string) => DecodedAction;

package/dist/messages/v2.2/execution.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeAction = exports.encodeAction = exports.getExecutionMessageId = exports.ActionType = void 0;
+const viem_1 = require("viem");
+var ActionType;
+(function (ActionType) {
+    ActionType[ActionType["MINT"] = 0] = "MINT";
+    ActionType[ActionType["BURN"] = 1] = "BURN";
+    ActionType[ActionType["TRANSFER"] = 2] = "TRANSFER";
+})(ActionType || (exports.ActionType = ActionType = {}));
+const getExecutionMessageId = (message) => {
+    return (0, viem_1.hashStruct)({
+        types: {
+            Execution: [
+                { name: "idempotencyKey", type: "bytes32" },
+                { name: "actions", type: "bytes[]" },
+            ],
+        },
+        primaryType: "Execution",
+        data: {
+            idempotencyKey: message.idempotencyKey,
+            actions: message.actions,
+        },
+    });
+};
+exports.getExecutionMessageId = getExecutionMessageId;
+const encodeAction = (action) => {
+    switch (action.type) {
+        case ActionType.MINT: {
+            return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                "uint8 type",
+                "address hubToAddress",
+                "uint256 hubTokenId",
+                "uint256 amount",
+            ]), [
+                action.type,
+                action.data.hubToAddress,
+                action.data.hubTokenId,
+                BigInt(action.data.amount),
+            ]);
+        }
+        case ActionType.BURN: {
+            return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                "uint8 type",
+                "address hubFromAddress",
+                "uint256 hubTokenId",
+                "uint256 amount",
+            ]), [
+                action.type,
+                action.data.hubFromAddress,
+                action.data.hubTokenId,
+                BigInt(action.data.amount),
+            ]);
+        }
+        case ActionType.TRANSFER: {
+            return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                "uint8 type",
+                "address hubFromAddress",
+                "address hubToAddress",
+                "uint256 hubTokenId",
+                "uint256 amount",
+            ]), [
+                action.type,
+                action.data.hubFromAddress,
+                action.data.hubToAddress,
+                action.data.hubTokenId,
+                BigInt(action.data.amount),
+            ]);
+        }
+        default: {
+            throw new Error("Unsupported action type");
+        }
+    }
+};
+exports.encodeAction = encodeAction;
+const decodeAction = (action) => {
+    // decode just the uint8 type
+    const [type] = (0, viem_1.decodeAbiParameters)((0, viem_1.parseAbiParameters)(["uint8 type"]), action);
+    switch (type) {
+        case ActionType.MINT: {
+            const result = (0, viem_1.decodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                "uint8 type",
+                "address hubToAddress",
+                "uint256 hubTokenId",
+                "uint256 amount",
+            ]), action);
+            return {
+                type: ActionType.MINT,
+                data: {
+                    hubToAddress: result[1].toString(),
+                    hubTokenId: result[2],
+                    amount: result[3].toString(),
+                },
+            };
+        }
+        case ActionType.BURN: {
+            const result = (0, viem_1.decodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                "uint8 type",
+                "address hubFromAddress",
+                "uint256 hubTokenId",
+                "uint256 amount",
+            ]), action);
+            return {
+                type: ActionType.BURN,
+                data: {
+                    hubFromAddress: result[1].toString(),
+                    hubTokenId: result[2],
+                    amount: result[3].toString(),
+                },
+            };
+        }
+        case ActionType.TRANSFER: {
+            const result = (0, viem_1.decodeAbiParameters)((0, viem_1.parseAbiParameters)([
+                "uint8 type",
+                "address hubFromAddress",
+                "address hubToAddress",
+                "uint256 hubTokenId",
+                "uint256 amount",
+            ]), action);
+            return {
+                type: ActionType.TRANSFER,
+                data: {
+                    hubFromAddress: result[1].toString(),
+                    hubToAddress: result[2].toString(),
+                    hubTokenId: result[3],
+                    amount: result[4].toString(),
+                },
+            };
+        }
+        default: {
+            throw new Error("Unsupported action type");
+        }
+    }
+};
+exports.decodeAction = decodeAction;

package/dist/messages/v2.2/withdrawal-execution.d.ts

@@ -0,0 +1,55 @@
+export interface SubmitWithdrawRequest {
+    chainId: string;
+    depository: string;
+    currency: string;
+    amount: string;
+    spender: string;
+    receiver: string;
+    data: string;
+    nonce: string;
+}
+export declare const getSubmitWithdrawRequestHash: (request: SubmitWithdrawRequest) => `0x${string}`;
+export type WithdrawalAddressParams = {
+    depositoryAddress: string;
+    depositoryChainId: bigint;
+    currency: string;
+    recipientAddress: string;
+    withdrawerAlias: string;
+    amount: bigint;
+    withdrawalNonce: string;
+};
+/**
+ * Compute deterministic withdrawal address
+ *
+ * @param depositoryAddress the depository contract holding the funds on origin chain
+ * @param depositoryChainId the chain id of the depository contract currently holding the funds
+ * @param currency the id of the currency as expressed on origin chain (string)
+ * @param recipientAddress the address that will receive the withdrawn funds on destination chain
+ * @param withdrawerAlias the address that owns the balance on the settlement chain
+ * before the withdrawal is initiated
+ * @param amount the balance to withdraw
+ * @param withdrawalNonce nonce to prevent collisions for similar withdrawals
+ * @returns withdrawal address (in lower case)
+ */
+export declare function getWithdrawalAddress(withdrawalParams: WithdrawalAddressParams): string;
+export type WithdrawalAddressRequest = Omit<WithdrawalAddressParams, "depositoryChainId" | "amount"> & {
+    depositoryChainSlug: string;
+    amount: string;
+};
+export type WithdrawalInitiationMessage = {
+    data: WithdrawalAddressRequest & {
+        settlementChainId: string;
+    };
+    result: {
+        withdrawalAddress: string;
+    };
+};
+export type WithdrawalInitiatedMessage = {
+    data: WithdrawalAddressRequest & {
+        settlementChainId: string;
+    };
+    result: {
+        proofOfWithdrawalAddressBalance: string;
+        withdrawalAddress: string;
+    };
+};

package/dist/messages/v2.2/withdrawal-execution.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSubmitWithdrawRequestHash = void 0;
+exports.getWithdrawalAddress = getWithdrawalAddress;
+const viem_1 = require("viem");
+const getSubmitWithdrawRequestHash = (request) => {
+    // EIP712 type from RelayAllocator
+    const PAYLOAD_TYPEHASH = (0, viem_1.keccak256)("SubmitWithdrawRequest(uint256 chainId,string depository,string currency,uint256 amount,address spender,string receiver,bytes data,bytes32 nonce)");
+    // Create EIP712 digest
+    const digest = (0, viem_1.keccak256)((0, viem_1.encodePacked)([
+        "bytes32",
+        "uint256",
+        "bytes32",
+        "bytes32",
+        "uint256",
+        "address",
+        "bytes32",
+        "bytes32",
+        "bytes32",
+    ], [
+        PAYLOAD_TYPEHASH,
+        BigInt(request.chainId),
+        (0, viem_1.keccak256)(request.depository),
+        (0, viem_1.keccak256)(request.currency),
+        BigInt(request.amount),
+        request.spender,
+        (0, viem_1.keccak256)(request.receiver),
+        (0, viem_1.keccak256)(request.data),
+        request.nonce,
+    ]));
+    // The withdrawal address is the digest itself (as a hex string)
+    return digest;
+};
+exports.getSubmitWithdrawRequestHash = getSubmitWithdrawRequestHash;
+/**
+ * Compute deterministic withdrawal address
+ *
+ * @param depositoryAddress the depository contract holding the funds on origin chain
+ * @param depositoryChainId the chain id of the depository contract currently holding the funds
+ * @param currency the id of the currency as expressed on origin chain (string)
+ * @param recipientAddress the address that will receive the withdrawn funds on destination chain
+ * @param withdrawerAlias the address that owns the balance on the settlement chain
+ * before the withdrawal is initiated
+ * @param amount the balance to withdraw
+ * @param withdrawalNonce nonce to prevent collisions for similar withdrawals
+ * @returns withdrawal address (in lower case)
+ */
+function getWithdrawalAddress(withdrawalParams) {
+    // pack and hash data
+    const nonce = (0, viem_1.keccak256)((0, viem_1.encodePacked)(["string"], [withdrawalParams.withdrawalNonce]));
+    const hash = (0, viem_1.keccak256)((0, viem_1.encodePacked)([
+        "address",
+        "uint256",
+        "string",
+        "address",
+        "address",
+        "uint256",
+        "bytes32",
+    ], [
+        withdrawalParams.depositoryAddress,
+        withdrawalParams.depositoryChainId,
+        withdrawalParams.currency,
+        withdrawalParams.recipientAddress,
+        withdrawalParams.withdrawerAlias,
+        withdrawalParams.amount,
+        nonce,
+    ]));
+    // get 40 bytes for an address
+    const withdrawalAddress = hash.slice(2).slice(-40).toLowerCase();
+    return `0x${withdrawalAddress}`;
+}

package/dist/order/index.d.ts

@@ -0,0 +1,140 @@
+import { ChainIdToVmType, VmType } from "../utils";
+export type Order = {
+    version: "v1";
+    solverChainId: string;
+    solver: string;
+    salt: string;
+    inputs: {
+        payment: {
+            chainId: string;
+            currency: string;
+            amount: string;
+            weight: string;
+        };
+        refunds: {
+            chainId: string;
+            recipient: string;
+            currency: string;
+            minimumAmount: string;
+            deadline: number;
+            extraData: string;
+        }[];
+    }[];
+    output: {
+        chainId: string;
+        payments: {
+            recipient: string;
+            currency: string;
+            minimumAmount: string;
+            expectedAmount: string;
+        }[];
+        calls: string[];
+        deadline: number;
+        extraData: string;
+    };
+    fees: {
+        recipientChainId: string;
+        recipient: string;
+        currencyChainId: string;
+        currency: string;
+        amount: string;
+    }[];
+};
+export declare const ORDER_EIP712_TYPES: {
+    Order: {
+        name: string;
+        type: string;
+    }[];
+    Input: {
+        name: string;
+        type: string;
+    }[];
+    InputPayment: {
+        name: string;
+        type: string;
+    }[];
+    InputRefund: {
+        name: string;
+        type: string;
+    }[];
+    Output: {
+        name: string;
+        type: string;
+    }[];
+    OutputPayment: {
+        name: string;
+        type: string;
+    }[];
+    Fee: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const normalizeOrder: (order: Order, chainsConfig: ChainIdToVmType) => {
+    version: "v1";
+    solverChainId: string;
+    solver: string;
+    salt: string;
+    inputs: {
+        payment: {
+            chainId: string;
+            currency: Uint8Array<ArrayBufferLike>;
+            amount: string;
+            weight: string;
+        };
+        refunds: {
+            chainId: string;
+            recipient: Uint8Array<ArrayBufferLike>;
+            currency: Uint8Array<ArrayBufferLike>;
+            minimumAmount: string;
+            deadline: number;
+            extraData: import("viem").ByteArray;
+        }[];
+    }[];
+    output: {
+        chainId: string;
+        payments: {
+            recipient: Uint8Array<ArrayBufferLike>;
+            currency: Uint8Array<ArrayBufferLike>;
+            minimumAmount: string;
+            expectedAmount: string;
+        }[];
+        calls: import("viem").ByteArray[];
+        deadline: number;
+        extraData: import("viem").ByteArray;
+    };
+    fees: {
+        recipientChainId: string;
+        recipient: Uint8Array<ArrayBufferLike>;
+        currencyChainId: string;
+        currency: Uint8Array<ArrayBufferLike>;
+        amount: string;
+    }[];
+};
+export declare const getOrderId: (order: Order, config: ChainIdToVmType) => `0x${string}`;
+type DecodedCall = {
+    vmType: "ethereum-vm";
+    call: {
+        to: string;
+        data: string;
+        value: string;
+    };
+};
+export declare const encodeOrderCall: (call: DecodedCall) => string;
+export declare const decodeOrderCall: (call: string, vmType: VmType) => DecodedCall;
+type DecodedExtraDataEthereumVm = {
+    vmType: "ethereum-vm";
+    extraData: {
+        fillContract: string;
+    };
+};
+type DecodedExtraDataTronVm = {
+    vmType: "tron-vm";
+    extraData: {
+        fillContract: string;
+    };
+};
+type DecodedExtraData = DecodedExtraDataEthereumVm | DecodedExtraDataTronVm;
+export declare const encodeOrderExtraData: (extraData: DecodedExtraData) => string;
+export declare const decodeOrderExtraData: (extraData: string, vmType: VmType) => DecodedExtraData;
+export {};