@0xmonaco/contracts 1.0.50 → 1.0.53

package/dist/sweeper.d.ts

@@ -1,10 +1,15 @@
 /**
  * Off-chain derivation of Monaco sweeper deposit addresses.
  *
- * A sweeper is an EIP-1167 clone deployed by `SweeperFactory` at a CREATE2
- * address determined by the (clientId, user, deposit target) triple it is
- * bound to. The address can therefore be shown to a user — and funded — before
- * any contract exists there, without an RPC round trip.
+ * A sweeper is an EIP-1167-style clone deployed by `SweeperFactory` at a
+ * CREATE2 address determined by the (clientId, user, deposit target) triple it
+ * is bound to. The address can therefore be shown to a user — and funded —
+ * before any contract exists there, without an RPC round trip. The clone
+ * delegates to the factory's fixed *forwarder* (which looks up the current
+ * sweeper implementation per call), so implementation upgrades never move
+ * addresses — and the forwarder, not the implementation, is the derivation
+ * input. The factory is deployed at the same address on every supported
+ * chain, which makes the derived deposit address chain-invariant too.
  *
  * The client id is the application's identifier as used for rollup deposits
  * (the string `sdk.login` takes). It is hashed **byte-for-byte**: two
@@ -53,10 +58,15 @@ export type DepositTarget = "spot" | "margin";
  */
 export declare function encodeDepositApplicationData(clientId: string, target: DepositTarget): string;
 export interface SweeperAddressInput {
-    /** Address of the deployed `SweeperFactory`. */
+    /** Address of the deployed `SweeperFactory` (the same on every chain). */
     factory: string;
-    /** Address of the `Sweeper` implementation the factory clones. */
-    implementation: string;
+    /**
+     * Address of the factory's `SweeperForwarder` — the fixed delegation
+     * target every clone points at (`factory.forwarder()`). NOT the sweeper
+     * implementation: the implementation is upgradeable and deliberately
+     * outside the derivation.
+     */
+    forwarder: string;
     /**
      * The application's client id, exactly as registered — hashed
      * byte-for-byte, so any other spelling derives a different address.
@@ -82,14 +92,21 @@ export interface SweeperAddressInput {
  * @throws If any address is malformed, the client id is empty, or the deposit
  *   target is not exactly `"spot"` or `"margin"`.
  */
-export declare function predictSweeperAddress({ factory, implementation, clientId, user, depositTarget }: SweeperAddressInput): Hex;
+export declare function predictSweeperAddress({ factory, forwarder, clientId, user, depositTarget }: SweeperAddressInput): Hex;
 /**
- * The clone's immutable args: `abi.encode(address user, string clientId)`
- * (the contract calls the string `applicationId`, matching the rollup's
- * deposit parameter name).
+ * The clone's immutable args:
+ * `abi.encode(address user, string clientId, address hubToken)` (the contract
+ * calls the string `applicationId`, matching the rollup's deposit parameter
+ * name).
+ *
+ * The hub token is zero for every user-facing deposit address; a non-zero
+ * value derives the factory's internal hub-side "unswap receiver" for that
+ * token, which the sweeping service uses when bridged funds must be swapped
+ * back before depositing.
  *
- * Length-prefixed rather than packed, so no pair can be confused with another.
+ * Length-prefixed rather than packed, so no triple can be confused with
+ * another.
  */
-export declare function sweeperImmutableArgs(user: string, clientId: string): Hex;
+export declare function sweeperImmutableArgs(user: string, clientId: string, hubToken?: string): Hex;
 /** The clone's creation code, mirroring OpenZeppelin `Clones._cloneCodeWithImmutableArgs`. */
-export declare function sweeperCloneInitCode(implementation: string, args: Hex): Hex;
+export declare function sweeperCloneInitCode(forwarder: string, args: Hex): Hex;

package/dist/sweeper.js

@@ -1,8 +1,8 @@
 import { keccak_256 } from "@noble/hashes/sha3";
 const ADDRESS = /^0x[0-9a-fA-F]{40}$/;
-/** EIP-1167-with-immutable-args runtime prefix, up to the implementation address. */
+/** EIP-1167-with-immutable-args runtime prefix, up to the delegation target. */
 const CLONE_RUNTIME_PREFIX = "3d81600a3d39f3363d3d373d3d3d363d73";
-/** EIP-1167-with-immutable-args runtime suffix, after the implementation address. */
+/** EIP-1167-with-immutable-args runtime suffix, after the delegation target. */
 const CLONE_RUNTIME_SUFFIX = "5af43d82803e903d91602b57fd5bf3";
 /** Byte length of the clone runtime code, excluding the immutable args. */
 const CLONE_RUNTIME_LENGTH = 45;
@@ -55,38 +55,44 @@ function assertDepositTarget(value) {
  * @throws If any address is malformed, the client id is empty, or the deposit
  *   target is not exactly `"spot"` or `"margin"`.
  */
-export function predictSweeperAddress({ factory, implementation, clientId, user, depositTarget = "spot" }) {
+export function predictSweeperAddress({ factory, forwarder, clientId, user, depositTarget = "spot" }) {
     const factoryAddress = assertAddress(factory, "factory");
-    const implementationAddress = assertAddress(implementation, "implementation");
+    const forwarderAddress = assertAddress(forwarder, "forwarder");
     const userAddress = assertNonZeroUser(assertAddress(user, "user"));
     assertClientId(clientId);
     // The bound string is the encoded application data, not the bare client id:
     // it is what the clone carries and what a sweep puts on-chain.
     const boundClientId = encodeDepositApplicationData(clientId, depositTarget);
-    const initCode = sweeperCloneInitCode(implementationAddress, sweeperImmutableArgs(userAddress, boundClientId));
+    const initCode = sweeperCloneInitCode(forwarderAddress, sweeperImmutableArgs(userAddress, boundClientId));
     const preimage = concatBytes(Uint8Array.of(0xff), hexToBytes(factoryAddress), SALT, keccak_256(hexToBytes(initCode)));
     return toChecksumAddress(`0x${bytesToHex(keccak_256(preimage).slice(12))}`);
 }
 /**
- * The clone's immutable args: `abi.encode(address user, string clientId)`
- * (the contract calls the string `applicationId`, matching the rollup's
- * deposit parameter name).
+ * The clone's immutable args:
+ * `abi.encode(address user, string clientId, address hubToken)` (the contract
+ * calls the string `applicationId`, matching the rollup's deposit parameter
+ * name).
  *
- * Length-prefixed rather than packed, so no pair can be confused with another.
+ * The hub token is zero for every user-facing deposit address; a non-zero
+ * value derives the factory's internal hub-side "unswap receiver" for that
+ * token, which the sweeping service uses when bridged funds must be swapped
+ * back before depositing.
+ *
+ * Length-prefixed rather than packed, so no triple can be confused with
+ * another.
  */
-export function sweeperImmutableArgs(user, clientId) {
+export function sweeperImmutableArgs(user, clientId, hubToken = "0x0000000000000000000000000000000000000000") {
     const userAddress = assertNonZeroUser(assertAddress(user, "user"));
+    const hubTokenAddress = assertAddress(hubToken, "hubToken");
     assertClientId(clientId);
-    return `0x${word(userAddress.slice(2))}${word("40")}${encodeStringTail(clientId)}`;
+    return `0x${word(userAddress.slice(2))}${word("60")}${word(hubTokenAddress.slice(2))}${encodeStringTail(clientId)}`;
 }
 /** The clone's creation code, mirroring OpenZeppelin `Clones._cloneCodeWithImmutableArgs`. */
-export function sweeperCloneInitCode(implementation, args) {
-    const implementationAddress = assertAddress(implementation, "implementation");
+export function sweeperCloneInitCode(forwarder, args) {
+    const forwarderAddress = assertAddress(forwarder, "forwarder");
     const argsHex = args.slice(2);
     const runtimeLength = argsHex.length / 2 + CLONE_RUNTIME_LENGTH;
-    return `0x61${runtimeLength.toString(16).padStart(4, "0")}${CLONE_RUNTIME_PREFIX}${implementationAddress
-        .slice(2)
-        .toLowerCase()}${CLONE_RUNTIME_SUFFIX}${argsHex}`;
+    return `0x61${runtimeLength.toString(16).padStart(4, "0")}${CLONE_RUNTIME_PREFIX}${forwarderAddress.slice(2).toLowerCase()}${CLONE_RUNTIME_SUFFIX}${argsHex}`;
 }
 function assertAddress(value, label) {
     if (!ADDRESS.test(value)) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/contracts",
-	"version": "1.0.50",
+	"version": "1.0.53",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",