@hyperlane-xyz/cli 31.2.1 → 32.0.1

package/bundle/{172.index.js → 773.index.js}

@@ -1,8 +1,8 @@
-export const id = 172;
-export const ids = [172];
+export const id = 773;
+export const ids = [773];
 export const modules = {
 
-/***/ 21172:
+/***/ 5773:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 
@@ -114,9 +114,9 @@ const STARKNET_DEFAULT_FEE_TOKEN_ADDRESSES = {
 };
 function getStarknetContract(contractName, address, providerOrAccount, contractType = starknet_dist_0/* ContractType */.h$.CONTRACT) {
     const { abi } = (0,starknet_dist_0/* getCompiledContract */.wm)(contractName, contractType);
-    return new starknet_dist/* Contract */.NZ(abi, normalizeStarknetAddressSafe(address), providerOrAccount);
+    return new starknet_dist/* Contract */.NZ(abi, contracts_normalizeStarknetAddressSafe(address), providerOrAccount);
 }
-function normalizeStarknetAddressSafe(value) {
+function contracts_normalizeStarknetAddressSafe(value) {
     if (typeof value === 'string') {
         if ((0,addresses/* isZeroishAddress */.Hi)(value))
             return addresses/* ZERO_ADDRESS_HEX_32 */.qx;
@@ -130,13 +130,13 @@ function normalizeStarknetAddressSafe(value) {
             return (0,starknet_dist/* addAddressPadding */.N6)((0,addresses/* ensure0x */.Ho)(starknet_dist/* uint256 */.iN.uint256ToBN(value).toString(16)));
         }
         if ('value' in value) {
-            return normalizeStarknetAddressSafe(value['value']);
+            return contracts_normalizeStarknetAddressSafe(value['value']);
         }
     }
     throw new Error(`Unable to normalize Starknet address: ${describeUnknown(value) || '[unsupported value]'}`);
 }
 function addressToEvmAddress(value) {
-    return (0,addresses/* bytes32ToAddress */.ov)(normalizeStarknetAddressSafe(value));
+    return (0,addresses/* bytes32ToAddress */.ov)(contracts_normalizeStarknetAddressSafe(value));
 }
 async function callContract(contract, method, args = []) {
     (0,validation/* assert */.v)(hasAbiMethod(contract, method), `Unable to call ${method} on contract ${contract.address}: method not found in ABI`);
@@ -162,7 +162,7 @@ async function populateInvokeTx(contract, method, args = []) {
         if (isPopulatedInvokeTx(tx)) {
             return {
                 kind: 'invoke',
-                contractAddress: normalizeStarknetAddressSafe(tx.contractAddress),
+                contractAddress: contracts_normalizeStarknetAddressSafe(tx.contractAddress),
                 entrypoint: tx.entrypoint,
                 calldata: tx.calldata ?? [],
             };
@@ -171,7 +171,7 @@ async function populateInvokeTx(contract, method, args = []) {
     const abi = getContractAbi(contract);
     return {
         kind: 'invoke',
-        contractAddress: normalizeStarknetAddressSafe(contract.address),
+        contractAddress: contracts_normalizeStarknetAddressSafe(contract.address),
         entrypoint: method,
         calldata: abi ? new starknet_dist/* CallData */.fP(abi).compile(method, args) : args,
     };
@@ -245,17 +245,17 @@ function toBigInt(value) {
 }
 function getFeeTokenAddress(params) {
     if (params.nativeDenom && !(0,addresses/* isZeroishAddress */.Hi)(params.nativeDenom)) {
-        return normalizeStarknetAddressSafe(params.nativeDenom);
+        return contracts_normalizeStarknetAddressSafe(params.nativeDenom);
     }
     const token = STARKNET_DEFAULT_FEE_TOKEN_ADDRESSES[params.chainName];
     (0,validation/* assert */.v)(token, `Missing Starknet fee token for chain ${params.chainName}`);
-    return normalizeStarknetAddressSafe(token);
+    return contracts_normalizeStarknetAddressSafe(token);
 }
 function normalizeRoutersAddress(value) {
     if (isUint256Like(value)) {
-        return normalizeStarknetAddressSafe(starknet_dist/* num */.bu.toHex(starknet_dist/* uint256 */.iN.uint256ToBN(value)));
+        return contracts_normalizeStarknetAddressSafe(starknet_dist/* num */.bu.toHex(starknet_dist/* uint256 */.iN.uint256ToBN(value)));
     }
-    return normalizeStarknetAddressSafe(value);
+    return contracts_normalizeStarknetAddressSafe(value);
 }
 /**
  * Creates a Contract instance using the on-chain ABI fetched from the provider.
@@ -266,7 +266,7 @@ function normalizeRoutersAddress(value) {
  * and Cairo 0 proxies (`implementation` returning a felt).
  */
 async function getOnChainStarknetContract(provider, address) {
-    const normalized = normalizeStarknetAddressSafe(address);
+    const normalized = contracts_normalizeStarknetAddressSafe(address);
     const { abi } = await provider.getClassAt(normalized);
     const contract = new starknet_dist/* Contract */.NZ(abi, normalized, provider);
     const implHash = await resolveImplementationHash(contract);
@@ -339,13 +339,55 @@ function shouldFallbackStorageRead(error) {
     const normalizedMessage = message.toLowerCase();
     return STORAGE_READ_FALLBACK_MESSAGES.some((fragment) => normalizedMessage.includes(fragment));
 }
+function isProbeMiss(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return [
+        'entry point',
+        'entrypoint',
+        'viewable method not found in abi',
+        'not found in abi',
+        'not found in contract',
+        'invalid message selector',
+    ].some((needle) => message.toLowerCase().includes(needle));
+}
 //# sourceMappingURL=contracts.js.map
+;// CONCATENATED MODULE: ../starknet-sdk/dist/mailbox/mailbox-query.js
+
+async function getMailboxConfig(provider, mailboxAddress) {
+    const mailbox = getStarknetContract(StarknetContractName.MAILBOX, mailboxAddress, provider);
+    const [owner, localDomain, defaultIsm, defaultHook, requiredHook, nonce] = await Promise.all([
+        callContract(mailbox, 'owner'),
+        callContract(mailbox, 'get_local_domain'),
+        callContract(mailbox, 'get_default_ism'),
+        callContract(mailbox, 'get_default_hook'),
+        callContract(mailbox, 'get_required_hook'),
+        callContract(mailbox, 'nonce'),
+    ]);
+    return {
+        address: contracts_normalizeStarknetAddressSafe(mailboxAddress),
+        owner: contracts_normalizeStarknetAddressSafe(owner),
+        localDomain: toNumber(localDomain),
+        defaultIsm: contracts_normalizeStarknetAddressSafe(defaultIsm),
+        defaultHook: contracts_normalizeStarknetAddressSafe(defaultHook),
+        requiredHook: contracts_normalizeStarknetAddressSafe(requiredHook),
+        nonce: toNumber(nonce),
+    };
+}
+async function isMessageDelivered(provider, mailboxAddress, messageId) {
+    const mailbox = getStarknetContract(StarknetContractName.MAILBOX, mailboxAddress, provider);
+    const delivered = await callContract(mailbox, 'delivered', [messageId]);
+    if (typeof delivered === 'boolean')
+        return delivered;
+    return toBigInt(delivered) !== 0n;
+}
+//# sourceMappingURL=mailbox-query.js.map
 ;// CONCATENATED MODULE: ../starknet-sdk/dist/clients/provider.js
 
 
 
 
 
+
 let tokenTypeByClassHash;
 function getTokenTypeByClassHash() {
     if (tokenTypeByClassHash) {
@@ -371,17 +413,6 @@ function getTokenTypeByClassHash() {
     ]));
     return tokenTypeByClassHash;
 }
-function isProbeMiss(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return [
-        'entry point',
-        'entrypoint',
-        'viewable method not found in abi',
-        'not found in abi',
-        'not found in contract',
-        'invalid message selector',
-    ].some((needle) => message.toLowerCase().includes(needle));
-}
 class StarknetProvider {
     provider;
     metadata;
@@ -418,6 +449,9 @@ class StarknetProvider {
             nativeDenom: this.metadata.nativeToken?.denom,
         });
     }
+    getFeeTokenAddress() {
+        return this.feeTokenAddress;
+    }
     parseString(value) {
         if (typeof value === 'string')
             return value;
@@ -447,7 +481,7 @@ class StarknetProvider {
         const tx = await populateInvokeTx(contract, method, args);
         (0,validation/* assert */.v)(tx.kind === 'invoke', 'Expected invoke Starknet transaction');
         return {
-            contractAddress: normalizeStarknetAddressSafe(tx.contractAddress),
+            contractAddress: contracts_normalizeStarknetAddressSafe(tx.contractAddress),
             entrypoint: tx.entrypoint,
             calldata: tx.calldata,
         };
@@ -459,7 +493,7 @@ class StarknetProvider {
         return value;
     }
     async determineTokenType(tokenAddress) {
-        const address = normalizeStarknetAddressSafe(tokenAddress);
+        const address = contracts_normalizeStarknetAddressSafe(tokenAddress);
         const classHash = await this.provider.getClassHashAt(address);
         const tokenType = getTokenTypeByClassHash().get(BigInt(classHash).toString());
         if (tokenType)
@@ -492,15 +526,15 @@ class StarknetProvider {
     async getTokenMetadata(tokenAddress) {
         const nativeToken = this.metadata.nativeToken;
         if (nativeToken?.denom &&
-            normalizeStarknetAddressSafe(tokenAddress) ===
-                normalizeStarknetAddressSafe(nativeToken.denom)) {
+            contracts_normalizeStarknetAddressSafe(tokenAddress) ===
+                contracts_normalizeStarknetAddressSafe(nativeToken.denom)) {
             return {
                 name: nativeToken.name,
                 symbol: nativeToken.symbol,
                 decimals: nativeToken.decimals ?? 18,
             };
         }
-        const address = normalizeStarknetAddressSafe(tokenAddress);
+        const address = contracts_normalizeStarknetAddressSafe(tokenAddress);
         const token = await getOnChainStarknetContract(this.provider, address);
         const [name, symbol, decimals] = await Promise.all([
             callContract(token, 'name'),
@@ -561,27 +595,27 @@ class StarknetProvider {
     }
     async getBalance(req) {
         const tokenAddress = req.denom
-            ? normalizeStarknetAddressSafe(req.denom)
+            ? contracts_normalizeStarknetAddressSafe(req.denom)
             : this.feeTokenAddress;
         const token = this.withContract(StarknetContractName.ETHER, tokenAddress, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
         let balance;
         try {
             balance = await callContract(token, 'balanceOf', [
-                normalizeStarknetAddressSafe(req.address),
+                contracts_normalizeStarknetAddressSafe(req.address),
             ]);
         }
         catch (error) {
             if (!isProbeMiss(error))
                 throw error;
             balance = await callContract(token, 'balance_of', [
-                normalizeStarknetAddressSafe(req.address),
+                contracts_normalizeStarknetAddressSafe(req.address),
             ]);
         }
         return toBigInt(this.unwrapBalance(balance));
     }
     async getTotalSupply(req) {
         const tokenAddress = req.denom
-            ? normalizeStarknetAddressSafe(req.denom)
+            ? contracts_normalizeStarknetAddressSafe(req.denom)
             : this.feeTokenAddress;
         const token = this.withContract(StarknetContractName.ETHER, tokenAddress, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
         return toBigInt(await callContract(token, 'total_supply'));
@@ -589,119 +623,12 @@ class StarknetProvider {
     async estimateTransactionFee(_req) {
         throw new Error('Starknet transaction fee estimation is unsupported without an account-backed signer');
     }
-    // ### QUERY CORE ###
-    async getMailbox(req) {
-        const mailbox = this.withContract(StarknetContractName.MAILBOX, req.mailboxAddress);
-        const [owner, localDomain, defaultIsm, defaultHook, requiredHook, nonce] = await Promise.all([
-            callContract(mailbox, 'owner'),
-            callContract(mailbox, 'get_local_domain'),
-            callContract(mailbox, 'get_default_ism'),
-            callContract(mailbox, 'get_default_hook'),
-            callContract(mailbox, 'get_required_hook'),
-            callContract(mailbox, 'nonce'),
-        ]);
-        return {
-            address: normalizeStarknetAddressSafe(req.mailboxAddress),
-            owner: normalizeStarknetAddressSafe(owner),
-            localDomain: toNumber(localDomain),
-            defaultIsm: normalizeStarknetAddressSafe(defaultIsm),
-            defaultHook: normalizeStarknetAddressSafe(defaultHook),
-            requiredHook: normalizeStarknetAddressSafe(requiredHook),
-            nonce: toNumber(nonce),
-        };
-    }
     async isMessageDelivered(req) {
-        const mailbox = this.withContract(StarknetContractName.MAILBOX, req.mailboxAddress);
-        const delivered = await callContract(mailbox, 'delivered', [req.messageId]);
-        if (typeof delivered === 'boolean')
-            return delivered;
-        return toBigInt(delivered) !== 0n;
-    }
-    async getIsmType(req) {
-        try {
-            const ism = this.withContract(StarknetContractName.MERKLE_ROOT_MULTISIG_ISM, req.ismAddress);
-            const moduleType = await callContract(ism, 'module_type');
-            return this.parseIsmVariant(extractEnumVariant(moduleType));
-        }
-        catch (error) {
-            if (!isProbeMiss(error))
-                throw error;
-            return dist/* AltVM.IsmType */.bx.GO.CUSTOM;
-        }
-    }
-    async getMessageIdMultisigIsm(req) {
-        const ism = this.withContract(StarknetContractName.MESSAGE_ID_MULTISIG_ISM, req.ismAddress);
-        const [validators, threshold] = await Promise.all([
-            callContract(ism, 'get_validators'),
-            callContract(ism, 'get_threshold'),
-        ]);
-        (0,validation/* assert */.v)(Array.isArray(validators), 'Expected Starknet validators array');
-        return {
-            address: normalizeStarknetAddressSafe(req.ismAddress),
-            threshold: toNumber(threshold),
-            validators: validators.map((v) => addressToEvmAddress(v)),
-        };
-    }
-    async getMerkleRootMultisigIsm(req) {
-        const ism = this.withContract(StarknetContractName.MERKLE_ROOT_MULTISIG_ISM, req.ismAddress);
-        const [validators, threshold] = await Promise.all([
-            callContract(ism, 'get_validators'),
-            callContract(ism, 'get_threshold'),
-        ]);
-        (0,validation/* assert */.v)(Array.isArray(validators), 'Expected Starknet validators array');
-        return {
-            address: normalizeStarknetAddressSafe(req.ismAddress),
-            threshold: toNumber(threshold),
-            validators: validators.map((v) => addressToEvmAddress(v)),
-        };
-    }
-    async getRoutingIsm(req) {
-        const ism = this.withContract(StarknetContractName.ROUTING_ISM, req.ismAddress);
-        const [owner, domains] = await Promise.all([
-            callContract(ism, 'owner'),
-            callContract(ism, 'domains'),
-        ]);
-        (0,validation/* assert */.v)(Array.isArray(domains), 'Expected Starknet routing domains array');
-        const routes = await Promise.all(domains.map(async (domainId) => {
-            const routeAddress = await callContract(ism, 'module', [domainId]);
-            return {
-                domainId: toNumber(domainId),
-                ismAddress: normalizeStarknetAddressSafe(routeAddress),
-            };
-        }));
-        return {
-            address: normalizeStarknetAddressSafe(req.ismAddress),
-            owner: normalizeStarknetAddressSafe(owner),
-            routes,
-        };
-    }
-    async getNoopIsm(req) {
-        return { address: normalizeStarknetAddressSafe(req.ismAddress) };
-    }
-    async getHookType(req) {
-        try {
-            const hook = this.withContract(StarknetContractName.HOOK, req.hookAddress);
-            const hookType = await callContract(hook, 'hook_type');
-            return this.parseHookVariant(extractEnumVariant(hookType));
-        }
-        catch (error) {
-            if (!isProbeMiss(error))
-                throw error;
-            return dist/* AltVM.HookType */.bx.WD.CUSTOM;
-        }
-    }
-    async getInterchainGasPaymasterHook(_req) {
-        throw new Error('interchainGasPaymaster hook type is unsupported on Starknet; use protocolFee hook type');
-    }
-    async getMerkleTreeHook(req) {
-        return { address: normalizeStarknetAddressSafe(req.hookAddress) };
-    }
-    async getNoopHook(req) {
-        return { address: normalizeStarknetAddressSafe(req.hookAddress) };
+        return isMessageDelivered(this.provider, req.mailboxAddress, req.messageId);
     }
     // ### QUERY WARP ###
     async getToken(req) {
-        const tokenAddress = normalizeStarknetAddressSafe(req.tokenAddress);
+        const tokenAddress = contracts_normalizeStarknetAddressSafe(req.tokenAddress);
         const token = this.withContract(StarknetContractName.HYP_ERC20, tokenAddress, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
         const tokenType = await this.determineTokenType(tokenAddress);
         const [owner, mailboxAddress, ismAddress, hookAddress] = await Promise.all([
@@ -727,7 +654,7 @@ class StarknetProvider {
         if (tokenType === dist/* AltVM.TokenType */.bx.ks.collateral) {
             const collateral = this.withContract(StarknetContractName.HYP_ERC20_COLLATERAL, tokenAddress, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
             const wrapped = await callContract(collateral, 'get_wrapped_token');
-            denom = normalizeStarknetAddressSafe(wrapped);
+            denom = contracts_normalizeStarknetAddressSafe(wrapped);
             try {
                 const wrappedMeta = await this.getTokenMetadata(denom);
                 name = wrappedMeta.name;
@@ -743,7 +670,7 @@ class StarknetProvider {
             const native = this.withContract(StarknetContractName.HYP_NATIVE, tokenAddress, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
             try {
                 const nativeTokenAddress = await callContract(native, 'native_token');
-                denom = normalizeStarknetAddressSafe(nativeTokenAddress);
+                denom = contracts_normalizeStarknetAddressSafe(nativeTokenAddress);
             }
             catch (error) {
                 if (!isProbeMiss(error))
@@ -756,11 +683,11 @@ class StarknetProvider {
         }
         return {
             address: tokenAddress,
-            owner: normalizeStarknetAddressSafe(owner),
+            owner: contracts_normalizeStarknetAddressSafe(owner),
             tokenType,
-            mailboxAddress: normalizeStarknetAddressSafe(mailboxAddress),
-            ismAddress: normalizeStarknetAddressSafe(ismAddress),
-            hookAddress: normalizeStarknetAddressSafe(hookAddress),
+            mailboxAddress: contracts_normalizeStarknetAddressSafe(mailboxAddress),
+            ismAddress: contracts_normalizeStarknetAddressSafe(ismAddress),
+            hookAddress: contracts_normalizeStarknetAddressSafe(hookAddress),
             denom,
             name,
             symbol,
@@ -784,7 +711,7 @@ class StarknetProvider {
             };
         }));
         return {
-            address: normalizeStarknetAddressSafe(req.tokenAddress),
+            address: contracts_normalizeStarknetAddressSafe(req.tokenAddress),
             remoteRouters,
         };
     }
@@ -809,255 +736,14 @@ class StarknetProvider {
             amount: toBigInt(quote),
         };
     }
-    // ### GET CORE TXS ###
-    async getCreateMailboxTransaction(req) {
-        return {
-            kind: 'deploy',
-            contractName: StarknetContractName.MAILBOX,
-            constructorArgs: [
-                req.domainId,
-                normalizeStarknetAddressSafe(req.signer),
-                normalizeStarknetAddressSafe(req.defaultIsmAddress ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx),
-                normalizeStarknetAddressSafe(req.defaultHookAddress ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx),
-                normalizeStarknetAddressSafe(req.requiredHookAddress ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx),
-            ],
-        };
-    }
-    async getSetDefaultIsmTransaction(req) {
-        const mailbox = this.withContract(StarknetContractName.MAILBOX, req.mailboxAddress);
-        return populateInvokeTx(mailbox, 'set_default_ism', [
-            normalizeStarknetAddressSafe(req.ismAddress),
-        ]);
-    }
-    async getSetDefaultHookTransaction(req) {
-        const mailbox = this.withContract(StarknetContractName.MAILBOX, req.mailboxAddress);
-        return populateInvokeTx(mailbox, 'set_default_hook', [
-            normalizeStarknetAddressSafe(req.hookAddress),
-        ]);
-    }
-    async getSetRequiredHookTransaction(req) {
-        const mailbox = this.withContract(StarknetContractName.MAILBOX, req.mailboxAddress);
-        return populateInvokeTx(mailbox, 'set_required_hook', [
-            normalizeStarknetAddressSafe(req.hookAddress),
-        ]);
-    }
-    async getSetMailboxOwnerTransaction(req) {
-        const mailbox = this.withContract(StarknetContractName.MAILBOX, req.mailboxAddress);
-        return populateInvokeTx(mailbox, 'transfer_ownership', [
-            normalizeStarknetAddressSafe(req.newOwner),
-        ]);
-    }
-    async getCreateMerkleRootMultisigIsmTransaction(req) {
-        return {
-            kind: 'deploy',
-            contractName: StarknetContractName.MERKLE_ROOT_MULTISIG_ISM,
-            constructorArgs: [
-                normalizeStarknetAddressSafe(req.signer),
-                req.validators.map((validator) => (0,addresses/* addressToBytes32 */.In)(validator)),
-                req.threshold,
-            ],
-        };
-    }
-    async getCreateMessageIdMultisigIsmTransaction(req) {
-        return {
-            kind: 'deploy',
-            contractName: StarknetContractName.MESSAGE_ID_MULTISIG_ISM,
-            constructorArgs: [
-                normalizeStarknetAddressSafe(req.signer),
-                req.validators.map((validator) => (0,addresses/* addressToBytes32 */.In)(validator)),
-                req.threshold,
-            ],
-        };
-    }
-    async getCreateRoutingIsmTransaction(req) {
-        return {
-            kind: 'deploy',
-            contractName: StarknetContractName.ROUTING_ISM,
-            constructorArgs: [normalizeStarknetAddressSafe(req.signer)],
-        };
-    }
-    async getSetRoutingIsmRouteTransaction(req) {
-        const routing = this.withContract(StarknetContractName.ROUTING_ISM, req.ismAddress);
-        return populateInvokeTx(routing, 'set', [
-            req.route.domainId,
-            normalizeStarknetAddressSafe(req.route.ismAddress),
-        ]);
-    }
-    async getRemoveRoutingIsmRouteTransaction(req) {
-        const routing = this.withContract(StarknetContractName.ROUTING_ISM, req.ismAddress);
-        return populateInvokeTx(routing, 'remove', [req.domainId]);
-    }
-    async getSetRoutingIsmOwnerTransaction(req) {
-        const routing = this.withContract(StarknetContractName.ROUTING_ISM, req.ismAddress);
-        return populateInvokeTx(routing, 'transfer_ownership', [
-            normalizeStarknetAddressSafe(req.newOwner),
-        ]);
-    }
-    async getCreateNoopIsmTransaction(_req) {
-        return {
-            kind: 'deploy',
-            contractName: StarknetContractName.NOOP_ISM,
-            constructorArgs: [],
-        };
-    }
-    async getCreateMerkleTreeHookTransaction(req) {
-        return {
-            kind: 'deploy',
-            contractName: StarknetContractName.MERKLE_TREE_HOOK,
-            constructorArgs: [
-                normalizeStarknetAddressSafe(req.mailboxAddress),
-                normalizeStarknetAddressSafe(req.signer),
-            ],
-        };
-    }
-    async getCreateInterchainGasPaymasterHookTransaction(_req) {
-        throw new Error('interchainGasPaymaster hook type is unsupported on Starknet; use protocolFee hook type');
-    }
-    async getSetInterchainGasPaymasterHookOwnerTransaction(_req) {
-        throw new Error('interchainGasPaymaster hook type is unsupported on Starknet; use protocolFee hook type');
-    }
-    async getSetDestinationGasConfigTransaction(_req) {
-        throw new Error('interchainGasPaymaster hook type is unsupported on Starknet');
-    }
-    async getRemoveDestinationGasConfigTransaction(_req) {
-        throw new Error('interchainGasPaymaster hook type is unsupported on Starknet');
-    }
-    async getCreateNoopHookTransaction(_req) {
-        return {
-            kind: 'deploy',
-            contractName: StarknetContractName.HOOK,
-            constructorArgs: [],
-        };
-    }
-    async getCreateValidatorAnnounceTransaction(req) {
-        return {
-            kind: 'deploy',
-            contractName: StarknetContractName.VALIDATOR_ANNOUNCE,
-            constructorArgs: [
-                normalizeStarknetAddressSafe(req.mailboxAddress),
-                normalizeStarknetAddressSafe(req.signer),
-            ],
-        };
-    }
-    async getCreateProxyAdminTransaction(_req) {
-        throw new Error('Proxy admin unsupported on Starknet');
-    }
-    async getSetProxyAdminOwnerTransaction(_req) {
-        throw new Error('Proxy admin unsupported on Starknet');
-    }
-    // ### GET WARP TXS ###
-    async getCreateNativeTokenTransaction(req) {
-        const mailbox = await this.getMailbox({
-            mailboxAddress: req.mailboxAddress,
-        });
-        return {
-            kind: 'deploy',
-            contractName: StarknetContractName.HYP_NATIVE,
-            contractType: starknet_dist_0/* ContractType */.h$.TOKEN,
-            constructorArgs: [
-                normalizeStarknetAddressSafe(req.mailboxAddress),
-                this.feeTokenAddress,
-                normalizeStarknetAddressSafe(mailbox.defaultHook),
-                normalizeStarknetAddressSafe(mailbox.defaultIsm),
-                normalizeStarknetAddressSafe(req.signer),
-            ],
-        };
-    }
-    async getCreateCollateralTokenTransaction(req) {
-        const mailbox = await this.getMailbox({
-            mailboxAddress: req.mailboxAddress,
-        });
-        return {
-            kind: 'deploy',
-            contractName: StarknetContractName.HYP_ERC20_COLLATERAL,
-            contractType: starknet_dist_0/* ContractType */.h$.TOKEN,
-            constructorArgs: [
-                normalizeStarknetAddressSafe(req.mailboxAddress),
-                normalizeStarknetAddressSafe(req.collateralDenom),
-                normalizeStarknetAddressSafe(req.signer),
-                normalizeStarknetAddressSafe(mailbox.defaultHook),
-                normalizeStarknetAddressSafe(mailbox.defaultIsm),
-            ],
-        };
-    }
-    async getCreateSyntheticTokenTransaction(req) {
-        const mailbox = await this.getMailbox({
-            mailboxAddress: req.mailboxAddress,
-        });
-        return {
-            kind: 'deploy',
-            contractName: StarknetContractName.HYP_ERC20,
-            contractType: starknet_dist_0/* ContractType */.h$.TOKEN,
-            constructorArgs: [
-                req.decimals,
-                normalizeStarknetAddressSafe(req.mailboxAddress),
-                0,
-                req.name,
-                req.denom,
-                normalizeStarknetAddressSafe(mailbox.defaultHook),
-                normalizeStarknetAddressSafe(mailbox.defaultIsm),
-                normalizeStarknetAddressSafe(req.signer),
-            ],
-        };
-    }
-    async getSetTokenOwnerTransaction(req) {
-        const token = this.withContract(StarknetContractName.HYP_ERC20, req.tokenAddress, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
-        return populateInvokeTx(token, 'transfer_ownership', [
-            normalizeStarknetAddressSafe(req.newOwner),
-        ]);
-    }
-    async getSetTokenIsmTransaction(req) {
-        const token = this.withContract(StarknetContractName.HYP_ERC20, req.tokenAddress, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
-        return populateInvokeTx(token, 'set_interchain_security_module', [
-            normalizeStarknetAddressSafe(req.ismAddress ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx),
-        ]);
-    }
-    async getSetTokenHookTransaction(req) {
-        const token = this.withContract(StarknetContractName.HYP_ERC20, req.tokenAddress, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
-        return populateInvokeTx(token, 'set_hook', [
-            normalizeStarknetAddressSafe(req.hookAddress ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx),
-        ]);
-    }
-    async getEnrollRemoteRouterTransaction(req) {
-        const token = this.withContract(StarknetContractName.HYP_ERC20, req.tokenAddress, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
-        const receiverAddress = (0,addresses/* isZeroishAddress */.Hi)(req.remoteRouter.receiverAddress)
-            ? addresses/* ZERO_ADDRESS_HEX_32 */.qx
-            : (0,addresses/* ensure0x */.Ho)(req.remoteRouter.receiverAddress);
-        const noneOption = new starknet_dist/* CairoOption */.ci(starknet_dist/* CairoOptionVariant */.RV.None);
-        const domainOption = new starknet_dist/* CairoOption */.ci(starknet_dist/* CairoOptionVariant */.RV.Some, req.remoteRouter.receiverDomainId);
-        const gasOption = new starknet_dist/* CairoOption */.ci(starknet_dist/* CairoOptionVariant */.RV.Some, req.remoteRouter.gas);
-        const [enrollCall, gasCall] = await Promise.all([
-            this.populateInvokeCall(token, 'enroll_remote_router', [
-                req.remoteRouter.receiverDomainId,
-                receiverAddress,
-            ]),
-            this.populateInvokeCall(token, 'set_destination_gas', [
-                noneOption,
-                domainOption,
-                gasOption,
-            ]),
-        ]);
-        return {
-            kind: 'invoke',
-            contractAddress: enrollCall.contractAddress,
-            entrypoint: enrollCall.entrypoint,
-            calldata: enrollCall.calldata,
-            calls: [enrollCall, gasCall],
-        };
-    }
-    async getUnenrollRemoteRouterTransaction(req) {
-        const token = this.withContract(StarknetContractName.HYP_ERC20, req.tokenAddress, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
-        return populateInvokeTx(token, 'unenroll_remote_router', [
-            req.receiverDomainId,
-        ]);
-    }
+    // ### TRANSFER TXS ###
     async getTransferTransaction(req) {
         const denom = req.denom
-            ? normalizeStarknetAddressSafe(req.denom)
+            ? contracts_normalizeStarknetAddressSafe(req.denom)
             : this.feeTokenAddress;
         const token = this.withContract(StarknetContractName.ETHER, denom, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
         return populateInvokeTx(token, 'transfer', [
-            normalizeStarknetAddressSafe(req.recipient),
+            contracts_normalizeStarknetAddressSafe(req.recipient),
             req.amount,
         ]);
     }
@@ -1116,7 +802,7 @@ class StarknetSigner extends StarknetProvider {
         const provider = StarknetProvider.connect(rpcUrls, metadata.chainId, {
             metadata,
         });
-        return new StarknetSigner(provider.getRawProvider(), metadata, rpcUrls, normalizeStarknetAddressSafe(accountAddress), privateKey);
+        return new StarknetSigner(provider.getRawProvider(), metadata, rpcUrls, contracts_normalizeStarknetAddressSafe(accountAddress), privateKey);
     }
     account;
     constructor(provider, metadata, rpcUrls, signerAddress, privateKey) {
@@ -1180,7 +866,7 @@ class StarknetSigner extends StarknetProvider {
         const rawAddress = deployment.address ||
             StarknetSigner.readStringField(deployment, 'contract_address');
         (0,validation/* assert */.v)(rawAddress, 'missing Starknet deploy contract address');
-        const address = normalizeStarknetAddressSafe(rawAddress);
+        const address = contracts_normalizeStarknetAddressSafe(rawAddress);
         const receipt = await this.account.waitForTransaction(transactionHash);
         this.assertSuccessfulReceipt(transactionHash, receipt);
         return {
@@ -1235,7 +921,6 @@ class StarknetSigner extends StarknetProvider {
         this.assertSuccessfulReceipt(transactionHash, receipt);
         return { transactionHash, receipt };
     }
-    // ### TX CORE ###
     async estimateTransactionFee(req) {
         (0,validation/* assert */.v)(req.transaction.kind === 'invoke', 'Starknet transaction fee estimation only supports invoke transactions');
         const calls = req.transaction.calls ?? [
@@ -1255,282 +940,6 @@ class StarknetSigner extends StarknetProvider {
             fee: estimate.overall_fee,
         };
     }
-    async createMailbox(req) {
-        if (req.proxyAdminAddress) {
-            throw new Error('Proxy admin unsupported on Starknet');
-        }
-        const defaultIsmAddress = req.defaultIsmAddress ?? (await this.createNoopIsm({})).ismAddress;
-        const defaultHookAddress = req.defaultHookAddress ??
-            (await this.createNoopHook({
-                // Hook deployment currently ignores mailboxAddress on Starknet.
-                mailboxAddress: this.signerAddress,
-            })).hookAddress;
-        // Keep required hooks opt-in. Auto-deploying a noop required hook would
-        // change mailbox semantics for callers that intentionally leave it unset.
-        const requiredHookAddress = req.requiredHookAddress;
-        const tx = await this.getCreateMailboxTransaction({
-            signer: this.signerAddress,
-            ...req,
-            defaultIsmAddress,
-            defaultHookAddress,
-            requiredHookAddress,
-        });
-        const receipt = await this.sendAndConfirmTransaction(tx);
-        (0,validation/* assert */.v)(receipt.contractAddress, 'failed to get Starknet mailbox address');
-        return { mailboxAddress: receipt.contractAddress };
-    }
-    async setDefaultIsm(req) {
-        const tx = await this.getSetDefaultIsmTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { ismAddress: req.ismAddress };
-    }
-    async setDefaultHook(req) {
-        const tx = await this.getSetDefaultHookTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { hookAddress: req.hookAddress };
-    }
-    async setRequiredHook(req) {
-        const tx = await this.getSetRequiredHookTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { hookAddress: req.hookAddress };
-    }
-    async setMailboxOwner(req) {
-        const tx = await this.getSetMailboxOwnerTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { newOwner: req.newOwner };
-    }
-    async createMerkleRootMultisigIsm(req) {
-        const tx = await this.getCreateMerkleRootMultisigIsmTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        const receipt = await this.sendAndConfirmTransaction(tx);
-        (0,validation/* assert */.v)(receipt.contractAddress, 'failed to get Starknet ISM address');
-        return { ismAddress: receipt.contractAddress };
-    }
-    async createMessageIdMultisigIsm(req) {
-        const tx = await this.getCreateMessageIdMultisigIsmTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        const receipt = await this.sendAndConfirmTransaction(tx);
-        (0,validation/* assert */.v)(receipt.contractAddress, 'failed to get Starknet ISM address');
-        return { ismAddress: receipt.contractAddress };
-    }
-    async createRoutingIsm(req) {
-        const tx = await this.getCreateRoutingIsmTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        const receipt = await this.sendAndConfirmTransaction(tx);
-        const ismAddress = receipt.contractAddress;
-        (0,validation/* assert */.v)(ismAddress, 'failed to get Starknet routing ISM address');
-        if (req.routes.length > 0) {
-            const routeTxs = await Promise.all(req.routes.map(async (route) => this.getSetRoutingIsmRouteTransaction({
-                signer: this.signerAddress,
-                ismAddress,
-                route,
-            })));
-            await this.sendAndConfirmBatchTransactions(routeTxs);
-        }
-        return { ismAddress };
-    }
-    async setRoutingIsmRoute(req) {
-        const tx = await this.getSetRoutingIsmRouteTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { route: req.route };
-    }
-    async removeRoutingIsmRoute(req) {
-        const tx = await this.getRemoveRoutingIsmRouteTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { domainId: req.domainId };
-    }
-    async setRoutingIsmOwner(req) {
-        const tx = await this.getSetRoutingIsmOwnerTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { newOwner: req.newOwner };
-    }
-    async createNoopIsm(req) {
-        const tx = await this.getCreateNoopIsmTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        const receipt = await this.sendAndConfirmTransaction(tx);
-        (0,validation/* assert */.v)(receipt.contractAddress, 'failed to get Starknet noop ISM address');
-        return { ismAddress: receipt.contractAddress };
-    }
-    async createMerkleTreeHook(req) {
-        const tx = await this.getCreateMerkleTreeHookTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        const receipt = await this.sendAndConfirmTransaction(tx);
-        (0,validation/* assert */.v)(receipt.contractAddress, 'failed to get Starknet hook address');
-        return { hookAddress: receipt.contractAddress };
-    }
-    async createInterchainGasPaymasterHook(req) {
-        const tx = await this.getCreateInterchainGasPaymasterHookTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        const receipt = await this.sendAndConfirmTransaction(tx);
-        (0,validation/* assert */.v)(receipt.contractAddress, 'failed to get Starknet interchainGasPaymaster hook');
-        return { hookAddress: receipt.contractAddress };
-    }
-    async setInterchainGasPaymasterHookOwner(req) {
-        const tx = await this.getSetInterchainGasPaymasterHookOwnerTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { newOwner: req.newOwner };
-    }
-    async setDestinationGasConfig(req) {
-        const tx = await this.getSetDestinationGasConfigTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { destinationGasConfig: req.destinationGasConfig };
-    }
-    async removeDestinationGasConfig(req) {
-        const tx = await this.getRemoveDestinationGasConfigTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { remoteDomainId: req.remoteDomainId };
-    }
-    async createNoopHook(req) {
-        const tx = await this.getCreateNoopHookTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        const receipt = await this.sendAndConfirmTransaction(tx);
-        (0,validation/* assert */.v)(receipt.contractAddress, 'failed to get Starknet noop hook');
-        return { hookAddress: receipt.contractAddress };
-    }
-    async createValidatorAnnounce(req) {
-        const tx = await this.getCreateValidatorAnnounceTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        const receipt = await this.sendAndConfirmTransaction(tx);
-        (0,validation/* assert */.v)(receipt.contractAddress, 'failed to get Starknet validator announce address');
-        return { validatorAnnounceId: receipt.contractAddress };
-    }
-    async createProxyAdmin(_req) {
-        throw new Error('Proxy admin unsupported on Starknet');
-    }
-    async setProxyAdminOwner(_req) {
-        throw new Error('Proxy admin unsupported on Starknet');
-    }
-    // ### TX WARP ###
-    async createNativeToken(req) {
-        if (req.proxyAdminAddress) {
-            throw new Error('Proxy admin unsupported on Starknet');
-        }
-        const tx = await this.getCreateNativeTokenTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        const receipt = await this.sendAndConfirmTransaction(tx);
-        (0,validation/* assert */.v)(receipt.contractAddress, 'failed to get Starknet warp token');
-        return { tokenAddress: receipt.contractAddress };
-    }
-    async createCollateralToken(req) {
-        if (req.proxyAdminAddress) {
-            throw new Error('Proxy admin unsupported on Starknet');
-        }
-        const tx = await this.getCreateCollateralTokenTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        const receipt = await this.sendAndConfirmTransaction(tx);
-        (0,validation/* assert */.v)(receipt.contractAddress, 'failed to get Starknet warp token');
-        return { tokenAddress: receipt.contractAddress };
-    }
-    async createSyntheticToken(req) {
-        if (req.proxyAdminAddress) {
-            throw new Error('Proxy admin unsupported on Starknet');
-        }
-        const tx = await this.getCreateSyntheticTokenTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        const receipt = await this.sendAndConfirmTransaction(tx);
-        (0,validation/* assert */.v)(receipt.contractAddress, 'failed to get Starknet warp token');
-        return { tokenAddress: receipt.contractAddress };
-    }
-    async setTokenOwner(req) {
-        const tx = await this.getSetTokenOwnerTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { newOwner: req.newOwner };
-    }
-    async setTokenIsm(req) {
-        const tx = await this.getSetTokenIsmTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { ismAddress: req.ismAddress ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx };
-    }
-    async setTokenHook(req) {
-        const tx = await this.getSetTokenHookTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { hookAddress: req.hookAddress ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx };
-    }
-    async enrollRemoteRouter(req) {
-        const tx = await this.getEnrollRemoteRouterTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { receiverDomainId: req.remoteRouter.receiverDomainId };
-    }
-    async unenrollRemoteRouter(req) {
-        const tx = await this.getUnenrollRemoteRouterTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { receiverDomainId: req.receiverDomainId };
-    }
-    async transfer(req) {
-        const tx = await this.getTransferTransaction({
-            signer: this.signerAddress,
-            ...req,
-        });
-        await this.sendAndConfirmTransaction(tx);
-        return { recipient: req.recipient };
-    }
     async remoteTransfer(req) {
         const token = await this.getToken({ tokenAddress: req.tokenAddress });
         const tokenType = token.tokenType;
@@ -1542,30 +951,30 @@ class StarknetSigner extends StarknetProvider {
         if (tokenType === dist/* AltVM.TokenType */.bx.ks.native) {
             const nativeToken = getStarknetContract(StarknetContractName.ETHER, token.denom, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
             batchedTxs.push(await populateInvokeTx(nativeToken, 'approve', [
-                normalizeStarknetAddressSafe(req.tokenAddress),
+                contracts_normalizeStarknetAddressSafe(req.tokenAddress),
                 toBigInt(req.amount) + toBigInt(req.maxFee.amount),
             ]));
         }
         else if (tokenType === dist/* AltVM.TokenType */.bx.ks.collateral) {
             const collateralToken = getStarknetContract(StarknetContractName.ETHER, token.denom, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
-            const collateralDenom = normalizeStarknetAddressSafe(token.denom);
-            const feeDenom = normalizeStarknetAddressSafe(req.maxFee.denom);
+            const collateralDenom = contracts_normalizeStarknetAddressSafe(token.denom);
+            const feeDenom = contracts_normalizeStarknetAddressSafe(req.maxFee.denom);
             const approvalAmount = collateralDenom === feeDenom
                 ? toBigInt(req.amount) + toBigInt(req.maxFee.amount)
                 : toBigInt(req.amount);
             batchedTxs.push(await populateInvokeTx(collateralToken, 'approve', [
-                normalizeStarknetAddressSafe(req.tokenAddress),
+                contracts_normalizeStarknetAddressSafe(req.tokenAddress),
                 approvalAmount,
             ]));
         }
         const usesSharedCollateralAndFeeToken = tokenType === dist/* AltVM.TokenType */.bx.ks.collateral &&
-            normalizeStarknetAddressSafe(token.denom) ===
-                normalizeStarknetAddressSafe(req.maxFee.denom);
+            contracts_normalizeStarknetAddressSafe(token.denom) ===
+                contracts_normalizeStarknetAddressSafe(req.maxFee.denom);
         if (tokenType !== dist/* AltVM.TokenType */.bx.ks.native &&
             !usesSharedCollateralAndFeeToken) {
             const feeToken = getStarknetContract(StarknetContractName.ETHER, req.maxFee.denom, this.provider, starknet_dist_0/* ContractType */.h$.TOKEN);
             batchedTxs.push(await populateInvokeTx(feeToken, 'approve', [
-                normalizeStarknetAddressSafe(req.tokenAddress),
+                contracts_normalizeStarknetAddressSafe(req.tokenAddress),
                 toBigInt(req.maxFee.amount),
             ]));
         }
@@ -1579,6 +988,36 @@ class StarknetSigner extends StarknetProvider {
     }
 }
 //# sourceMappingURL=signer.js.map
+;// CONCATENATED MODULE: ../starknet-sdk/dist/hook/hook-query.js
+
+
+function parseHookVariant(variant) {
+    const upper = variant.toUpperCase();
+    if (upper.includes('MERKLE_TREE'))
+        return dist/* AltVM.HookType */.bx.WD.MERKLE_TREE;
+    if (upper.includes('PROTOCOL_FEE'))
+        return dist/* AltVM.HookType */.bx.WD.PROTOCOL_FEE;
+    if (upper.includes('INTERCHAIN_GAS_PAYMASTER')) {
+        return dist/* AltVM.HookType */.bx.WD.INTERCHAIN_GAS_PAYMASTER;
+    }
+    return dist/* AltVM.HookType */.bx.WD.CUSTOM;
+}
+async function getHookType(provider, hookAddress) {
+    try {
+        const hook = getStarknetContract(StarknetContractName.HOOK, hookAddress, provider);
+        const hookType = await callContract(hook, 'hook_type');
+        return parseHookVariant(extractEnumVariant(hookType));
+    }
+    catch (error) {
+        if (!isProbeMiss(error))
+            throw error;
+        return dist/* AltVM.HookType */.bx.WD.CUSTOM;
+    }
+}
+function getMerkleTreeHookConfig(hookAddress) {
+    return { address: normalizeStarknetAddressSafe(hookAddress) };
+}
+//# sourceMappingURL=hook-query.js.map
 ;// CONCATENATED MODULE: ../starknet-sdk/dist/hook/interchain-gas-paymaster-hook-artifact-manager.js
 
 
@@ -1605,17 +1044,38 @@ function createStarknetInterchainGasPaymasterHookWriter() {
 //# sourceMappingURL=interchain-gas-paymaster-hook-artifact-manager.js.map
 // EXTERNAL MODULE: ../provider-sdk/dist/artifact.js
 var dist_artifact = __webpack_require__(4287);
+;// CONCATENATED MODULE: ../starknet-sdk/dist/hook/hook-tx.js
+
+function getCreateMerkleTreeHookTx(signer, mailboxAddress) {
+    return {
+        kind: 'deploy',
+        contractName: StarknetContractName.MERKLE_TREE_HOOK,
+        constructorArgs: [
+            contracts_normalizeStarknetAddressSafe(mailboxAddress),
+            contracts_normalizeStarknetAddressSafe(signer),
+        ],
+    };
+}
+function getCreateNoopHookTx() {
+    return {
+        kind: 'deploy',
+        contractName: StarknetContractName.HOOK,
+        constructorArgs: [],
+    };
+}
+//# sourceMappingURL=hook-tx.js.map
 ;// CONCATENATED MODULE: ../starknet-sdk/dist/hook/merkle-tree-hook-artifact-manager.js
 
 
 
 
+
 class StarknetMerkleTreeHookReader {
     async read(address) {
         return {
             artifactState: dist_artifact/* ArtifactState */.O2.DEPLOYED,
             config: { type: dist/* AltVM.HookType */.bx.WD.MERKLE_TREE },
-            deployed: { address: normalizeStarknetAddressSafe(address) },
+            deployed: { address: contracts_normalizeStarknetAddressSafe(address) },
         };
     }
 }
@@ -1628,10 +1088,7 @@ class StarknetMerkleTreeHookWriter extends StarknetMerkleTreeHookReader {
         this.mailboxAddress = mailboxAddress;
     }
     async create(artifact) {
-        const tx = await this.signer.getCreateMerkleTreeHookTransaction({
-            signer: this.signer.getSignerAddress(),
-            mailboxAddress: this.mailboxAddress,
-        });
+        const tx = getCreateMerkleTreeHookTx(this.signer.getSignerAddress(), this.mailboxAddress);
         const receipt = await this.signer.sendAndConfirmTransaction(tx);
         const hookAddress = receipt.contractAddress;
         (0,validation/* assert */.v)(hookAddress, 'failed to deploy Starknet merkle tree hook');
@@ -1711,15 +1168,15 @@ class StarknetProtocolFeeHookReader {
         this.provider = provider;
     }
     async read(address) {
-        const normalizedAddress = normalizeStarknetAddressSafe(address);
+        const normalizedAddress = contracts_normalizeStarknetAddressSafe(address);
         const hook = getStarknetContract(StarknetContractName.PROTOCOL_FEE, normalizedAddress, this.provider.getRawProvider());
         const [owner, beneficiary, protocolFee] = await Promise.all([
             callContract(hook, 'owner'),
             callContract(hook, 'get_beneficiary'),
             callContract(hook, 'get_protocol_fee'),
         ]);
-        const ownerAddress = normalizeStarknetAddressSafe(owner);
-        const beneficiaryAddress = normalizeStarknetAddressSafe(beneficiary);
+        const ownerAddress = contracts_normalizeStarknetAddressSafe(owner);
+        const beneficiaryAddress = contracts_normalizeStarknetAddressSafe(beneficiary);
         const protocolFeeAmount = toBigInt(protocolFee);
         const maxProtocolFee = await readProtocolFeeMaxFromStorage(this.provider, normalizedAddress, protocolFeeAmount);
         const config = {
@@ -1763,8 +1220,8 @@ class StarknetProtocolFeeHookWriter extends StarknetProtocolFeeHookReader {
             constructorArgs: [
                 artifact.config.maxProtocolFee,
                 artifact.config.protocolFee,
-                normalizeStarknetAddressSafe(artifact.config.beneficiary),
-                normalizeStarknetAddressSafe(artifact.config.owner),
+                contracts_normalizeStarknetAddressSafe(artifact.config.beneficiary),
+                contracts_normalizeStarknetAddressSafe(artifact.config.owner),
                 tokenAddress,
             ],
         };
@@ -1775,7 +1232,7 @@ class StarknetProtocolFeeHookWriter extends StarknetProtocolFeeHookReader {
                 artifactState: dist_artifact/* ArtifactState */.O2.DEPLOYED,
                 config: artifact.config,
                 deployed: {
-                    address: normalizeStarknetAddressSafe(receipt.contractAddress),
+                    address: contracts_normalizeStarknetAddressSafe(receipt.contractAddress),
                 },
             },
             [receipt],
@@ -1795,7 +1252,7 @@ class StarknetProtocolFeeHookWriter extends StarknetProtocolFeeHookReader {
             txs.push({
                 annotation: `Updating protocol fee beneficiary for ${contractAddress}`,
                 ...(await populateInvokeTx(contract, 'set_beneficiary', [
-                    normalizeStarknetAddressSafe(artifact.config.beneficiary),
+                    contracts_normalizeStarknetAddressSafe(artifact.config.beneficiary),
                 ])),
             });
         }
@@ -1811,7 +1268,7 @@ class StarknetProtocolFeeHookWriter extends StarknetProtocolFeeHookReader {
             txs.push({
                 annotation: `Transferring protocol fee hook ownership for ${contractAddress}`,
                 ...(await populateInvokeTx(contract, 'transfer_ownership', [
-                    normalizeStarknetAddressSafe(artifact.config.owner),
+                    contracts_normalizeStarknetAddressSafe(artifact.config.owner),
                 ])),
             });
         }
@@ -1827,7 +1284,7 @@ class StarknetUnknownHookReader {
         return {
             artifactState: dist_artifact/* ArtifactState */.O2.DEPLOYED,
             config: { type: 'unknownHook' },
-            deployed: { address: normalizeStarknetAddressSafe(address) },
+            deployed: { address: contracts_normalizeStarknetAddressSafe(address) },
         };
     }
 }
@@ -1851,6 +1308,7 @@ class StarknetUnknownHookWriter extends StarknetUnknownHookReader {
 
 
 
+
 class StarknetHookArtifactManager {
     chainMetadata;
     provider;
@@ -1859,7 +1317,7 @@ class StarknetHookArtifactManager {
         this.chainMetadata = chainMetadata;
         this.provider = StarknetProvider.connect((chainMetadata.rpcUrls ?? []).map(({ http }) => http), chainMetadata.chainId, { metadata: chainMetadata });
         this.mailboxAddress = context?.mailbox
-            ? normalizeStarknetAddressSafe(context.mailbox)
+            ? contracts_normalizeStarknetAddressSafe(context.mailbox)
             : '';
     }
     requireStarknetSigner(signer) {
@@ -1867,9 +1325,7 @@ class StarknetHookArtifactManager {
         return signer;
     }
     async readHook(address) {
-        const hookType = await this.provider.getHookType({
-            hookAddress: address,
-        });
+        const hookType = await getHookType(this.provider.getRawProvider(), address);
         switch (hookType) {
             case dist/* AltVM.HookType */.bx.WD.CUSTOM:
                 return this.createReader('unknownHook').read(address);
@@ -1913,19 +1369,154 @@ class StarknetHookArtifactManager {
 //# sourceMappingURL=hook-artifact-manager.js.map
 // EXTERNAL MODULE: ../provider-sdk/dist/ism.js
 var ism = __webpack_require__(96426);
+;// CONCATENATED MODULE: ../starknet-sdk/dist/ism/ism-query.js
+
+
+
+function parseIsmVariant(variant) {
+    const upper = variant.toUpperCase();
+    if (upper.includes('TEST') ||
+        upper.includes('NOOP') ||
+        upper.includes('NULL') ||
+        upper.includes('UNUSED')) {
+        return dist/* AltVM.IsmType */.bx.GO.TEST_ISM;
+    }
+    if (upper.includes('MERKLE_ROOT_MULTISIG')) {
+        return dist/* AltVM.IsmType */.bx.GO.MERKLE_ROOT_MULTISIG;
+    }
+    if (upper.includes('MESSAGE_ID_MULTISIG')) {
+        return dist/* AltVM.IsmType */.bx.GO.MESSAGE_ID_MULTISIG;
+    }
+    if (upper.includes('ROUTING')) {
+        return dist/* AltVM.IsmType */.bx.GO.ROUTING;
+    }
+    return dist/* AltVM.IsmType */.bx.GO.CUSTOM;
+}
+async function getIsmType(provider, ismAddress) {
+    try {
+        const ism = getStarknetContract(StarknetContractName.MERKLE_ROOT_MULTISIG_ISM, ismAddress, provider);
+        const moduleType = await callContract(ism, 'module_type');
+        return parseIsmVariant(extractEnumVariant(moduleType));
+    }
+    catch (error) {
+        if (!isProbeMiss(error))
+            throw error;
+        return dist/* AltVM.IsmType */.bx.GO.CUSTOM;
+    }
+}
+async function getMultisigIsmConfig(provider, ismAddress, contractName) {
+    const ism = getStarknetContract(contractName, ismAddress, provider);
+    const [validators, threshold] = await Promise.all([
+        callContract(ism, 'get_validators'),
+        callContract(ism, 'get_threshold'),
+    ]);
+    (0,validation/* assert */.v)(Array.isArray(validators), 'Expected Starknet validators array');
+    return {
+        address: contracts_normalizeStarknetAddressSafe(ismAddress),
+        threshold: toNumber(threshold),
+        validators: validators.map((v) => addressToEvmAddress(v)),
+    };
+}
+async function getMessageIdMultisigIsmConfig(provider, ismAddress) {
+    return getMultisigIsmConfig(provider, ismAddress, StarknetContractName.MESSAGE_ID_MULTISIG_ISM);
+}
+async function getMerkleRootMultisigIsmConfig(provider, ismAddress) {
+    return getMultisigIsmConfig(provider, ismAddress, StarknetContractName.MERKLE_ROOT_MULTISIG_ISM);
+}
+async function getRoutingIsmConfig(provider, ismAddress) {
+    const ism = getStarknetContract(StarknetContractName.ROUTING_ISM, ismAddress, provider);
+    const [owner, domains] = await Promise.all([
+        callContract(ism, 'owner'),
+        callContract(ism, 'domains'),
+    ]);
+    (0,validation/* assert */.v)(Array.isArray(domains), 'Expected Starknet routing domains array');
+    const routes = await Promise.all(domains.map(async (domainId) => {
+        const routeAddress = await callContract(ism, 'module', [domainId]);
+        return {
+            domainId: toNumber(domainId),
+            ismAddress: contracts_normalizeStarknetAddressSafe(routeAddress),
+        };
+    }));
+    return {
+        address: contracts_normalizeStarknetAddressSafe(ismAddress),
+        owner: contracts_normalizeStarknetAddressSafe(owner),
+        routes,
+    };
+}
+function getNoopIsmConfig(ismAddress) {
+    return { address: contracts_normalizeStarknetAddressSafe(ismAddress) };
+}
+//# sourceMappingURL=ism-query.js.map
+;// CONCATENATED MODULE: ../starknet-sdk/dist/ism/ism-tx.js
+
+
+function getCreateMerkleRootMultisigIsmTx(signer, config) {
+    return {
+        kind: 'deploy',
+        contractName: StarknetContractName.MERKLE_ROOT_MULTISIG_ISM,
+        constructorArgs: [
+            contracts_normalizeStarknetAddressSafe(signer),
+            config.validators.map((validator) => (0,addresses/* addressToBytes32 */.In)(validator)),
+            config.threshold,
+        ],
+    };
+}
+function getCreateMessageIdMultisigIsmTx(signer, config) {
+    return {
+        kind: 'deploy',
+        contractName: StarknetContractName.MESSAGE_ID_MULTISIG_ISM,
+        constructorArgs: [
+            contracts_normalizeStarknetAddressSafe(signer),
+            config.validators.map((validator) => (0,addresses/* addressToBytes32 */.In)(validator)),
+            config.threshold,
+        ],
+    };
+}
+function getCreateRoutingIsmTx(signer) {
+    return {
+        kind: 'deploy',
+        contractName: StarknetContractName.ROUTING_ISM,
+        constructorArgs: [contracts_normalizeStarknetAddressSafe(signer)],
+    };
+}
+async function getSetRoutingIsmRouteTx(provider, config) {
+    const routing = getStarknetContract(StarknetContractName.ROUTING_ISM, config.ismAddress, provider);
+    return populateInvokeTx(routing, 'set', [
+        config.route.domainId,
+        contracts_normalizeStarknetAddressSafe(config.route.ismAddress),
+    ]);
+}
+async function getRemoveRoutingIsmRouteTx(provider, config) {
+    const routing = getStarknetContract(StarknetContractName.ROUTING_ISM, config.ismAddress, provider);
+    return populateInvokeTx(routing, 'remove', [config.domainId]);
+}
+async function getSetRoutingIsmOwnerTx(provider, config) {
+    const routing = getStarknetContract(StarknetContractName.ROUTING_ISM, config.ismAddress, provider);
+    return populateInvokeTx(routing, 'transfer_ownership', [
+        contracts_normalizeStarknetAddressSafe(config.newOwner),
+    ]);
+}
+function getCreateNoopIsmTx() {
+    return {
+        kind: 'deploy',
+        contractName: StarknetContractName.NOOP_ISM,
+        constructorArgs: [],
+    };
+}
+//# sourceMappingURL=ism-tx.js.map
 ;// CONCATENATED MODULE: ../starknet-sdk/dist/ism/domain-routing-ism-artifact-manager.js
 
 
 
+
+
 class StarknetRoutingIsmReader {
     provider;
     constructor(provider) {
         this.provider = provider;
     }
     async read(address) {
-        const routing = await this.provider.getRoutingIsm({
-            ismAddress: address,
-        });
+        const routing = await getRoutingIsmConfig(this.provider.getRawProvider(), address);
         const domains = {};
         for (const route of routing.routes) {
             domains[route.domainId] = {
@@ -1960,25 +1551,21 @@ class StarknetRoutingIsmWriter extends StarknetRoutingIsmReader {
             };
         });
         const receipts = [];
-        const createTx = await this.signer.getCreateRoutingIsmTransaction({
-            signer: this.signer.getSignerAddress(),
-            routes,
-        });
+        const createTx = getCreateRoutingIsmTx(this.signer.getSignerAddress());
         const createReceipt = await this.signer.sendAndConfirmTransaction(createTx);
         receipts.push(createReceipt);
         const ismAddress = createReceipt.contractAddress;
         (0,validation/* assert */.v)(ismAddress, 'failed to get Starknet routing ISM address');
+        const rawProvider = this.signer.getRawProvider();
         for (const route of routes) {
-            const tx = await this.signer.getSetRoutingIsmRouteTransaction({
-                signer: this.signer.getSignerAddress(),
+            const tx = await getSetRoutingIsmRouteTx(rawProvider, {
                 ismAddress,
                 route,
             });
             receipts.push(await this.signer.sendAndConfirmTransaction(tx));
         }
         if (!(0,addresses/* eqAddressStarknet */.PD)(artifact.config.owner, this.signer.getSignerAddress())) {
-            const ownerTx = await this.signer.getSetRoutingIsmOwnerTransaction({
-                signer: this.signer.getSignerAddress(),
+            const ownerTx = await getSetRoutingIsmOwnerTx(rawProvider, {
                 ismAddress,
                 newOwner: artifact.config.owner,
             });
@@ -1999,25 +1586,25 @@ class StarknetRoutingIsmWriter extends StarknetRoutingIsmReader {
             if ((0,dist_artifact/* isArtifactUnderived */.l2)(domainIsm) || (0,dist_artifact/* isArtifactDeployed */.R)(domainIsm)) {
                 return {
                     domainId: Number(domainId),
-                    ismAddress: normalizeStarknetAddressSafe(domainIsm.deployed.address),
+                    ismAddress: contracts_normalizeStarknetAddressSafe(domainIsm.deployed.address),
                 };
             }
             throw new Error(`Routing ISM domain ${domainId} has invalid state`);
         });
         const actualByDomain = new Map(Object.entries(current.config.domains).map(([domainId, domainIsm]) => [
             Number(domainId),
-            normalizeStarknetAddressSafe(domainIsm.deployed.address),
+            contracts_normalizeStarknetAddressSafe(domainIsm.deployed.address),
         ]));
         const expectedByDomain = new Map(expectedRoutes.map((route) => [route.domainId, route.ismAddress]));
         const updateTxs = [];
+        const rawProvider = this.signer.getRawProvider();
         for (const route of expectedRoutes) {
             const actualAddress = actualByDomain.get(route.domainId);
             if (!actualAddress ||
                 !(0,addresses/* eqAddressStarknet */.PD)(actualAddress, route.ismAddress)) {
                 updateTxs.push({
                     annotation: `Setting routing ISM route ${route.domainId}`,
-                    ...(await this.signer.getSetRoutingIsmRouteTransaction({
-                        signer: this.signer.getSignerAddress(),
+                    ...(await getSetRoutingIsmRouteTx(rawProvider, {
                         ismAddress: artifact.deployed.address,
                         route,
                     })),
@@ -2028,8 +1615,7 @@ class StarknetRoutingIsmWriter extends StarknetRoutingIsmReader {
             if (!expectedByDomain.has(domainId)) {
                 updateTxs.push({
                     annotation: `Removing routing ISM route ${domainId}`,
-                    ...(await this.signer.getRemoveRoutingIsmRouteTransaction({
-                        signer: this.signer.getSignerAddress(),
+                    ...(await getRemoveRoutingIsmRouteTx(rawProvider, {
                         ismAddress: artifact.deployed.address,
                         domainId,
                     })),
@@ -2039,8 +1625,7 @@ class StarknetRoutingIsmWriter extends StarknetRoutingIsmReader {
         if (!(0,addresses/* eqAddressStarknet */.PD)(current.config.owner, artifact.config.owner)) {
             updateTxs.push({
                 annotation: `Updating routing ISM owner`,
-                ...(await this.signer.getSetRoutingIsmOwnerTransaction({
-                    signer: this.signer.getSignerAddress(),
+                ...(await getSetRoutingIsmOwnerTx(rawProvider, {
                     ismAddress: artifact.deployed.address,
                     newOwner: artifact.config.owner,
                 })),
@@ -2054,15 +1639,15 @@ class StarknetRoutingIsmWriter extends StarknetRoutingIsmReader {
 
 
 
+
+
 class StarknetMerkleRootMultisigIsmReader {
     provider;
     constructor(provider) {
         this.provider = provider;
     }
     async read(address) {
-        const ism = await this.provider.getMerkleRootMultisigIsm({
-            ismAddress: address,
-        });
+        const ism = await getMerkleRootMultisigIsmConfig(this.provider.getRawProvider(), address);
         return {
             artifactState: dist_artifact/* ArtifactState */.O2.DEPLOYED,
             config: {
@@ -2081,8 +1666,7 @@ class StarknetMerkleRootMultisigIsmWriter extends StarknetMerkleRootMultisigIsmR
         this.signer = signer;
     }
     async create(artifact) {
-        const tx = await this.signer.getCreateMerkleRootMultisigIsmTransaction({
-            signer: this.signer.getSignerAddress(),
+        const tx = getCreateMerkleRootMultisigIsmTx(this.signer.getSignerAddress(), {
             validators: artifact.config.validators,
             threshold: artifact.config.threshold,
         });
@@ -2107,15 +1691,15 @@ class StarknetMerkleRootMultisigIsmWriter extends StarknetMerkleRootMultisigIsmR
 
 
 
+
+
 class StarknetMessageIdMultisigIsmReader {
     provider;
     constructor(provider) {
         this.provider = provider;
     }
     async read(address) {
-        const ism = await this.provider.getMessageIdMultisigIsm({
-            ismAddress: address,
-        });
+        const ism = await getMessageIdMultisigIsmConfig(this.provider.getRawProvider(), address);
         return {
             artifactState: dist_artifact/* ArtifactState */.O2.DEPLOYED,
             config: {
@@ -2134,8 +1718,7 @@ class StarknetMessageIdMultisigIsmWriter extends StarknetMessageIdMultisigIsmRea
         this.signer = signer;
     }
     async create(artifact) {
-        const tx = await this.signer.getCreateMessageIdMultisigIsmTransaction({
-            signer: this.signer.getSignerAddress(),
+        const tx = getCreateMessageIdMultisigIsmTx(this.signer.getSignerAddress(), {
             validators: artifact.config.validators,
             threshold: artifact.config.threshold,
         });
@@ -2160,13 +1743,15 @@ class StarknetMessageIdMultisigIsmWriter extends StarknetMessageIdMultisigIsmRea
 
 
 
+
+
 class StarknetTestIsmReader {
     provider;
     constructor(provider) {
         this.provider = provider;
     }
     async read(address) {
-        const noop = await this.provider.getNoopIsm({ ismAddress: address });
+        const noop = getNoopIsmConfig(address);
         return {
             artifactState: dist_artifact/* ArtifactState */.O2.DEPLOYED,
             config: { type: dist/* AltVM.IsmType */.bx.GO.TEST_ISM },
@@ -2181,9 +1766,7 @@ class StarknetTestIsmWriter extends StarknetTestIsmReader {
         this.signer = signer;
     }
     async create(artifact) {
-        const tx = await this.signer.getCreateNoopIsmTransaction({
-            signer: this.signer.getSignerAddress(),
-        });
+        const tx = getCreateNoopIsmTx();
         const receipt = await this.signer.sendAndConfirmTransaction(tx);
         const ismAddress = receipt.contractAddress;
         (0,validation/* assert */.v)(ismAddress, 'failed to deploy Starknet noop ISM');
@@ -2211,6 +1794,7 @@ class StarknetTestIsmWriter extends StarknetTestIsmReader {
 
 
 
+
 class StarknetIsmArtifactManager {
     provider;
     constructor(chainMetadata) {
@@ -2221,7 +1805,7 @@ class StarknetIsmArtifactManager {
         return signer;
     }
     async readIsm(address) {
-        const type = await this.provider.getIsmType({ ismAddress: address });
+        const type = await getIsmType(this.provider.getRawProvider(), address);
         if (type === dist/* AltVM.IsmType */.bx.GO.CUSTOM) {
             return this.createReader(dist/* AltVM.IsmType */.bx.GO.TEST_ISM).read(address);
         }
@@ -2253,21 +1837,63 @@ class StarknetIsmArtifactManager {
     }
 }
 //# sourceMappingURL=ism-artifact-manager.js.map
+;// CONCATENATED MODULE: ../starknet-sdk/dist/mailbox/mailbox-tx.js
+
+
+function getCreateMailboxTx(signer, config) {
+    return {
+        kind: 'deploy',
+        contractName: StarknetContractName.MAILBOX,
+        constructorArgs: [
+            config.domainId,
+            contracts_normalizeStarknetAddressSafe(signer),
+            contracts_normalizeStarknetAddressSafe(config.defaultIsmAddress ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx),
+            contracts_normalizeStarknetAddressSafe(config.defaultHookAddress ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx),
+            contracts_normalizeStarknetAddressSafe(config.requiredHookAddress ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx),
+        ],
+    };
+}
+async function getSetDefaultIsmTx(provider, config) {
+    const mailbox = getStarknetContract(StarknetContractName.MAILBOX, config.mailboxAddress, provider);
+    return populateInvokeTx(mailbox, 'set_default_ism', [
+        contracts_normalizeStarknetAddressSafe(config.ismAddress),
+    ]);
+}
+async function getSetDefaultHookTx(provider, config) {
+    const mailbox = getStarknetContract(StarknetContractName.MAILBOX, config.mailboxAddress, provider);
+    return populateInvokeTx(mailbox, 'set_default_hook', [
+        contracts_normalizeStarknetAddressSafe(config.hookAddress),
+    ]);
+}
+async function getSetRequiredHookTx(provider, config) {
+    const mailbox = getStarknetContract(StarknetContractName.MAILBOX, config.mailboxAddress, provider);
+    return populateInvokeTx(mailbox, 'set_required_hook', [
+        contracts_normalizeStarknetAddressSafe(config.hookAddress),
+    ]);
+}
+async function getSetMailboxOwnerTx(provider, config) {
+    const mailbox = getStarknetContract(StarknetContractName.MAILBOX, config.mailboxAddress, provider);
+    return populateInvokeTx(mailbox, 'transfer_ownership', [
+        contracts_normalizeStarknetAddressSafe(config.newOwner),
+    ]);
+}
+//# sourceMappingURL=mailbox-tx.js.map
 ;// CONCATENATED MODULE: ../starknet-sdk/dist/mailbox/mailbox-artifact-manager.js
 
 
 
 
 
+
+
+
 class StarknetMailboxReader {
     provider;
     constructor(provider) {
         this.provider = provider;
     }
     async read(address) {
-        const mailbox = await this.provider.getMailbox({
-            mailboxAddress: address,
-        });
+        const mailbox = await getMailboxConfig(this.provider.getRawProvider(), address);
         return {
             artifactState: dist_artifact/* ArtifactState */.O2.DEPLOYED,
             config: {
@@ -2275,24 +1901,24 @@ class StarknetMailboxReader {
                 defaultIsm: {
                     artifactState: dist_artifact/* ArtifactState */.O2.UNDERIVED,
                     deployed: {
-                        address: normalizeStarknetAddressSafe(mailbox.defaultIsm),
+                        address: contracts_normalizeStarknetAddressSafe(mailbox.defaultIsm),
                     },
                 },
                 defaultHook: {
                     artifactState: dist_artifact/* ArtifactState */.O2.UNDERIVED,
                     deployed: {
-                        address: normalizeStarknetAddressSafe(mailbox.defaultHook),
+                        address: contracts_normalizeStarknetAddressSafe(mailbox.defaultHook),
                     },
                 },
                 requiredHook: {
                     artifactState: dist_artifact/* ArtifactState */.O2.UNDERIVED,
                     deployed: {
-                        address: normalizeStarknetAddressSafe(mailbox.requiredHook),
+                        address: contracts_normalizeStarknetAddressSafe(mailbox.requiredHook),
                     },
                 },
             },
             deployed: {
-                address: normalizeStarknetAddressSafe(mailbox.address),
+                address: contracts_normalizeStarknetAddressSafe(mailbox.address),
                 domainId: mailbox.localDomain,
             },
         };
@@ -2307,21 +1933,18 @@ class StarknetMailboxWriter extends StarknetMailboxReader {
         this.chainMetadata = chainMetadata;
     }
     getNestedAddress(nested) {
-        return normalizeStarknetAddressSafe(nested.deployed.address);
+        return contracts_normalizeStarknetAddressSafe(nested.deployed.address);
     }
     async getInitialHookAddress(address, receipts, placeholderRef) {
         if (!(0,addresses/* isZeroishAddress */.Hi)(address)) {
-            return normalizeStarknetAddressSafe(address);
+            return contracts_normalizeStarknetAddressSafe(address);
         }
         if (!placeholderRef.address) {
-            const tx = await this.signer.getCreateNoopHookTransaction({
-                signer: this.signer.getSignerAddress(),
-                mailboxAddress: '',
-            });
+            const tx = getCreateNoopHookTx();
             const receipt = await this.signer.sendAndConfirmTransaction(tx);
             receipts.push(receipt);
             (0,validation/* assert */.v)(receipt.contractAddress, 'failed to deploy placeholder Starknet noop hook');
-            placeholderRef.address = normalizeStarknetAddressSafe(receipt.contractAddress);
+            placeholderRef.address = contracts_normalizeStarknetAddressSafe(receipt.contractAddress);
         }
         return placeholderRef.address;
     }
@@ -2331,32 +1954,22 @@ class StarknetMailboxWriter extends StarknetMailboxReader {
         const placeholderHookRef = {};
         const defaultHookAddress = await this.getInitialHookAddress(this.getNestedAddress(artifact.config.defaultHook), receipts, placeholderHookRef);
         const requiredHookAddress = await this.getInitialHookAddress(this.getNestedAddress(artifact.config.requiredHook), receipts, placeholderHookRef);
-        const createTx = await this.signer.getCreateMailboxTransaction({
-            signer: this.signer.getSignerAddress(),
+        const createTx = getCreateMailboxTx(this.signer.getSignerAddress(), {
             domainId: this.chainMetadata.domainId,
             defaultIsmAddress,
             defaultHookAddress,
             requiredHookAddress,
-            proxyAdminAddress: undefined,
         });
         const createReceipt = await this.signer.sendAndConfirmTransaction(createTx);
         receipts.push(createReceipt);
         (0,validation/* assert */.v)(createReceipt.contractAddress, 'failed to deploy Starknet mailbox');
         const mailboxAddress = createReceipt.contractAddress;
-        if (!(0,addresses/* eqAddressStarknet */.PD)(artifact.config.owner, this.signer.getSignerAddress())) {
-            const tx = await this.signer.getSetMailboxOwnerTransaction({
-                signer: this.signer.getSignerAddress(),
-                mailboxAddress,
-                newOwner: artifact.config.owner,
-            });
-            receipts.push(await this.signer.sendAndConfirmTransaction(tx));
-        }
         return [
             {
                 artifactState: dist_artifact/* ArtifactState */.O2.DEPLOYED,
                 config: artifact.config,
                 deployed: {
-                    address: normalizeStarknetAddressSafe(mailboxAddress),
+                    address: contracts_normalizeStarknetAddressSafe(mailboxAddress),
                     domainId: this.chainMetadata.domainId,
                 },
             },
@@ -2373,11 +1986,11 @@ class StarknetMailboxWriter extends StarknetMailboxReader {
         const currentDefaultIsm = this.getNestedAddress(current.config.defaultIsm);
         const currentDefaultHook = this.getNestedAddress(current.config.defaultHook);
         const currentRequiredHook = this.getNestedAddress(current.config.requiredHook);
+        const rawProvider = this.signer.getRawProvider();
         if (!(0,addresses/* eqAddressStarknet */.PD)(currentDefaultIsm, expectedDefaultIsm)) {
             updateTxs.push({
                 annotation: `Setting mailbox default ISM`,
-                ...(await this.signer.getSetDefaultIsmTransaction({
-                    signer: this.signer.getSignerAddress(),
+                ...(await getSetDefaultIsmTx(rawProvider, {
                     mailboxAddress,
                     ismAddress: expectedDefaultIsm,
                 })),
@@ -2386,8 +1999,7 @@ class StarknetMailboxWriter extends StarknetMailboxReader {
         if (!(0,addresses/* eqAddressStarknet */.PD)(currentDefaultHook, expectedDefaultHook)) {
             updateTxs.push({
                 annotation: `Setting mailbox default hook`,
-                ...(await this.signer.getSetDefaultHookTransaction({
-                    signer: this.signer.getSignerAddress(),
+                ...(await getSetDefaultHookTx(rawProvider, {
                     mailboxAddress,
                     hookAddress: expectedDefaultHook,
                 })),
@@ -2396,8 +2008,7 @@ class StarknetMailboxWriter extends StarknetMailboxReader {
         if (!(0,addresses/* eqAddressStarknet */.PD)(currentRequiredHook, expectedRequiredHook)) {
             updateTxs.push({
                 annotation: `Setting mailbox required hook`,
-                ...(await this.signer.getSetRequiredHookTransaction({
-                    signer: this.signer.getSignerAddress(),
+                ...(await getSetRequiredHookTx(rawProvider, {
                     mailboxAddress,
                     hookAddress: expectedRequiredHook,
                 })),
@@ -2406,8 +2017,7 @@ class StarknetMailboxWriter extends StarknetMailboxReader {
         if (!(0,addresses/* eqAddressStarknet */.PD)(current.config.owner, artifact.config.owner)) {
             updateTxs.push({
                 annotation: `Setting mailbox owner`,
-                ...(await this.signer.getSetMailboxOwnerTransaction({
-                    signer: this.signer.getSignerAddress(),
+                ...(await getSetMailboxOwnerTx(rawProvider, {
                     mailboxAddress,
                     newOwner: artifact.config.owner,
                 })),
@@ -2448,6 +2058,19 @@ class StarknetMailboxArtifactManager {
     }
 }
 //# sourceMappingURL=mailbox-artifact-manager.js.map
+;// CONCATENATED MODULE: ../starknet-sdk/dist/validator-announce/validator-announce-tx.js
+
+function getCreateValidatorAnnounceTx(signer, mailboxAddress) {
+    return {
+        kind: 'deploy',
+        contractName: StarknetContractName.VALIDATOR_ANNOUNCE,
+        constructorArgs: [
+            contracts_normalizeStarknetAddressSafe(mailboxAddress),
+            contracts_normalizeStarknetAddressSafe(signer),
+        ],
+    };
+}
+//# sourceMappingURL=validator-announce-tx.js.map
 ;// CONCATENATED MODULE: ../starknet-sdk/dist/validator-announce/validator-announce-artifact-manager.js
 
 
@@ -2455,6 +2078,7 @@ class StarknetMailboxArtifactManager {
 
 
 
+
 const validator_announce_artifact_manager_STARKNET_STORAGE_ADDRESS_BOUND = (1n << 251n) - 256n;
 const validator_announce_artifact_manager_logger = logging/* rootLogger */.Jk.child({
     module: 'starknet-validator-announce-artifact-manager',
@@ -2467,7 +2091,7 @@ async function readStorageAddress(provider, contractAddress, key) {
             .getStorageAt(contractAddress, `0x${key.toString(16)}`);
         return (0,addresses/* isZeroishAddress */.Hi)(value)
             ? undefined
-            : normalizeStarknetAddressSafe(value);
+            : contracts_normalizeStarknetAddressSafe(value);
     }
     catch (error) {
         if (!shouldFallbackStorageRead(error)) {
@@ -2486,7 +2110,7 @@ async function readMailboxAddressFromStorage(provider, contractAddress) {
     if (candidates.length === 0)
         return undefined;
     const uniqueCandidates = [
-        ...new Set(candidates.map((value) => normalizeStarknetAddressSafe(value))),
+        ...new Set(candidates.map((value) => contracts_normalizeStarknetAddressSafe(value))),
     ];
     return uniqueCandidates.length === 1 ? uniqueCandidates[0] : undefined;
 }
@@ -2496,7 +2120,7 @@ class StarknetValidatorAnnounceReader {
         this.provider = provider;
     }
     async read(address) {
-        const normalizedAddress = normalizeStarknetAddressSafe(address);
+        const normalizedAddress = contracts_normalizeStarknetAddressSafe(address);
         const mailboxAddress = await readMailboxAddressFromStorage(this.provider, normalizedAddress);
         const config = {
             mailboxAddress: mailboxAddress ?? '',
@@ -2524,10 +2148,7 @@ class StarknetValidatorAnnounceWriter extends StarknetValidatorAnnounceReader {
         this.signer = signer;
     }
     async create(artifact) {
-        const tx = await this.signer.getCreateValidatorAnnounceTransaction({
-            signer: this.signer.getSignerAddress(),
-            mailboxAddress: artifact.config.mailboxAddress,
-        });
+        const tx = getCreateValidatorAnnounceTx(this.signer.getSignerAddress(), artifact.config.mailboxAddress);
         const receipt = await this.signer.sendAndConfirmTransaction(tx);
         const validatorAnnounceId = receipt.contractAddress;
         (0,validation/* assert */.v)(validatorAnnounceId, 'failed to get Starknet validator announce address');
@@ -2536,7 +2157,7 @@ class StarknetValidatorAnnounceWriter extends StarknetValidatorAnnounceReader {
                 artifactState: dist_artifact/* ArtifactState */.O2.DEPLOYED,
                 config: artifact.config,
                 deployed: {
-                    address: normalizeStarknetAddressSafe(validatorAnnounceId),
+                    address: contracts_normalizeStarknetAddressSafe(validatorAnnounceId),
                 },
             },
             [receipt],
@@ -2578,11 +2199,123 @@ class StarknetValidatorAnnounceArtifactManager {
 //# sourceMappingURL=validator-announce-artifact-manager.js.map
 // EXTERNAL MODULE: ../provider-sdk/dist/warp.js
 var warp = __webpack_require__(17791);
+;// CONCATENATED MODULE: ../starknet-sdk/dist/warp/warp-tx.js
+
+
+
+
+function getCreateNativeTokenTx(signer, config) {
+    return {
+        kind: 'deploy',
+        contractName: StarknetContractName.HYP_NATIVE,
+        contractType: starknet_dist_0/* ContractType */.h$.TOKEN,
+        constructorArgs: [
+            contracts_normalizeStarknetAddressSafe(config.mailboxAddress),
+            contracts_normalizeStarknetAddressSafe(config.feeTokenAddress),
+            contracts_normalizeStarknetAddressSafe(config.defaultHook),
+            contracts_normalizeStarknetAddressSafe(config.defaultIsm),
+            contracts_normalizeStarknetAddressSafe(signer),
+        ],
+    };
+}
+function getCreateCollateralTokenTx(signer, config) {
+    return {
+        kind: 'deploy',
+        contractName: StarknetContractName.HYP_ERC20_COLLATERAL,
+        contractType: starknet_dist_0/* ContractType */.h$.TOKEN,
+        constructorArgs: [
+            contracts_normalizeStarknetAddressSafe(config.mailboxAddress),
+            contracts_normalizeStarknetAddressSafe(config.collateralDenom),
+            contracts_normalizeStarknetAddressSafe(signer),
+            contracts_normalizeStarknetAddressSafe(config.defaultHook),
+            contracts_normalizeStarknetAddressSafe(config.defaultIsm),
+        ],
+    };
+}
+function getCreateSyntheticTokenTx(signer, config) {
+    return {
+        kind: 'deploy',
+        contractName: StarknetContractName.HYP_ERC20,
+        contractType: starknet_dist_0/* ContractType */.h$.TOKEN,
+        constructorArgs: [
+            config.decimals,
+            contracts_normalizeStarknetAddressSafe(config.mailboxAddress),
+            0, // initial supply
+            config.name,
+            config.denom,
+            contracts_normalizeStarknetAddressSafe(config.defaultHook),
+            contracts_normalizeStarknetAddressSafe(config.defaultIsm),
+            contracts_normalizeStarknetAddressSafe(signer),
+        ],
+    };
+}
+async function getSetTokenOwnerTx(provider, config) {
+    const token = getStarknetContract(StarknetContractName.HYP_ERC20, config.tokenAddress, provider, starknet_dist_0/* ContractType */.h$.TOKEN);
+    return populateInvokeTx(token, 'transfer_ownership', [
+        contracts_normalizeStarknetAddressSafe(config.newOwner),
+    ]);
+}
+async function getSetTokenIsmTx(provider, config) {
+    const token = getStarknetContract(StarknetContractName.HYP_ERC20, config.tokenAddress, provider, starknet_dist_0/* ContractType */.h$.TOKEN);
+    return populateInvokeTx(token, 'set_interchain_security_module', [
+        contracts_normalizeStarknetAddressSafe(config.ismAddress ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx),
+    ]);
+}
+async function getSetTokenHookTx(provider, config) {
+    const token = getStarknetContract(StarknetContractName.HYP_ERC20, config.tokenAddress, provider, starknet_dist_0/* ContractType */.h$.TOKEN);
+    return populateInvokeTx(token, 'set_hook', [
+        contracts_normalizeStarknetAddressSafe(config.hookAddress ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx),
+    ]);
+}
+async function populateInvokeCall(provider, tokenAddress, method, args = []) {
+    const contract = getStarknetContract(StarknetContractName.HYP_ERC20, tokenAddress, provider, starknet_dist_0/* ContractType */.h$.TOKEN);
+    const tx = await populateInvokeTx(contract, method, args);
+    (0,validation/* assert */.v)(tx.kind === 'invoke', 'Expected invoke Starknet transaction');
+    return {
+        contractAddress: contracts_normalizeStarknetAddressSafe(tx.contractAddress),
+        entrypoint: tx.entrypoint,
+        calldata: tx.calldata,
+    };
+}
+async function getEnrollRemoteRouterTx(provider, config) {
+    const receiverAddress = (0,addresses/* isZeroishAddress */.Hi)(config.remoteRouter.receiverAddress)
+        ? addresses/* ZERO_ADDRESS_HEX_32 */.qx
+        : (0,addresses/* ensure0x */.Ho)(config.remoteRouter.receiverAddress);
+    const noneOption = new starknet_dist/* CairoOption */.ci(starknet_dist/* CairoOptionVariant */.RV.None);
+    const domainOption = new starknet_dist/* CairoOption */.ci(starknet_dist/* CairoOptionVariant */.RV.Some, config.remoteRouter.receiverDomainId);
+    const gasOption = new starknet_dist/* CairoOption */.ci(starknet_dist/* CairoOptionVariant */.RV.Some, config.remoteRouter.gas);
+    const [enrollCall, gasCall] = await Promise.all([
+        populateInvokeCall(provider, config.tokenAddress, 'enroll_remote_router', [
+            config.remoteRouter.receiverDomainId,
+            receiverAddress,
+        ]),
+        populateInvokeCall(provider, config.tokenAddress, 'set_destination_gas', [
+            noneOption,
+            domainOption,
+            gasOption,
+        ]),
+    ]);
+    return {
+        kind: 'invoke',
+        contractAddress: enrollCall.contractAddress,
+        entrypoint: enrollCall.entrypoint,
+        calldata: enrollCall.calldata,
+        calls: [enrollCall, gasCall],
+    };
+}
+async function getUnenrollRemoteRouterTx(provider, config) {
+    const token = getStarknetContract(StarknetContractName.HYP_ERC20, config.tokenAddress, provider, starknet_dist_0/* ContractType */.h$.TOKEN);
+    return populateInvokeTx(token, 'unenroll_remote_router', [
+        config.receiverDomainId,
+    ]);
+}
+//# sourceMappingURL=warp-tx.js.map
 ;// CONCATENATED MODULE: ../starknet-sdk/dist/warp/token-artifact-manager.js
 
 
 
 
+
 function normalizeGas(gas) {
     return BigInt(gas ?? '0').toString();
 }
@@ -2612,7 +2345,7 @@ class StarknetWarpTokenReaderBase {
         return {
             artifactState: dist_artifact/* ArtifactState */.O2.DEPLOYED,
             config: this.toConfig(token, remoteRouters),
-            deployed: { address: normalizeStarknetAddressSafe(token.address) },
+            deployed: { address: contracts_normalizeStarknetAddressSafe(token.address) },
         };
     }
     baseConfig(token, remoteRouters) {
@@ -2620,15 +2353,15 @@ class StarknetWarpTokenReaderBase {
         const destinationGas = {};
         for (const remoteRouter of remoteRouters.remoteRouters) {
             routers[remoteRouter.receiverDomainId] = {
-                address: normalizeStarknetAddressSafe(remoteRouter.receiverAddress),
+                address: contracts_normalizeStarknetAddressSafe(remoteRouter.receiverAddress),
             };
             destinationGas[remoteRouter.receiverDomainId] = normalizeGas(remoteRouter.gas);
         }
         return {
-            owner: normalizeStarknetAddressSafe(token.owner),
-            mailbox: normalizeStarknetAddressSafe(token.mailboxAddress),
-            interchainSecurityModule: (0,dist_artifact/* addressToUnderivedArtifact */.Se)(token.ismAddress, normalizeStarknetAddressSafe),
-            hook: (0,dist_artifact/* addressToUnderivedArtifact */.Se)(token.hookAddress, normalizeStarknetAddressSafe),
+            owner: contracts_normalizeStarknetAddressSafe(token.owner),
+            mailbox: contracts_normalizeStarknetAddressSafe(token.mailboxAddress),
+            interchainSecurityModule: (0,dist_artifact/* addressToUnderivedArtifact */.Se)(token.ismAddress, contracts_normalizeStarknetAddressSafe),
+            hook: (0,dist_artifact/* addressToUnderivedArtifact */.Se)(token.hookAddress, contracts_normalizeStarknetAddressSafe),
             remoteRouters: routers,
             destinationGas,
         };
@@ -2666,7 +2399,7 @@ class StarknetWarpTokenWriterBase extends StarknetWarpTokenReaderBase {
             {
                 artifactState: dist_artifact/* ArtifactState */.O2.DEPLOYED,
                 config: artifact.config,
-                deployed: { address: normalizeStarknetAddressSafe(tokenAddress) },
+                deployed: { address: contracts_normalizeStarknetAddressSafe(tokenAddress) },
             },
             receipts,
         ];
@@ -2683,32 +2416,29 @@ class StarknetWarpTokenWriterBase extends StarknetWarpTokenReaderBase {
         if (!(0,addresses/* eqAddressStarknet */.PD)(currentOwner, expectedConfig.owner)) {
             ownerTx = {
                 annotation: 'Setting warp token owner',
-                ...(await this.signer.getSetTokenOwnerTransaction({
-                    signer: this.signer.getSignerAddress(),
+                ...(await getSetTokenOwnerTx(this.provider.getRawProvider(), {
                     tokenAddress,
                     newOwner: expectedConfig.owner,
                 })),
             };
         }
-        const currentIsm = (0,dist_artifact/* artifactOnChainToAddress */.wM)(current.config.interchainSecurityModule, normalizeStarknetAddressSafe);
-        const expectedIsm = (0,dist_artifact/* artifactOnChainToAddress */.wM)(expectedConfig.interchainSecurityModule, normalizeStarknetAddressSafe);
+        const currentIsm = (0,dist_artifact/* artifactOnChainToAddress */.wM)(current.config.interchainSecurityModule, contracts_normalizeStarknetAddressSafe);
+        const expectedIsm = (0,dist_artifact/* artifactOnChainToAddress */.wM)(expectedConfig.interchainSecurityModule, contracts_normalizeStarknetAddressSafe);
         if (!(0,addresses/* eqAddressStarknet */.PD)(currentIsm ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx, expectedIsm ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx)) {
             txs.push({
                 annotation: 'Setting warp token ISM',
-                ...(await this.signer.getSetTokenIsmTransaction({
-                    signer: this.signer.getSignerAddress(),
+                ...(await getSetTokenIsmTx(this.provider.getRawProvider(), {
                     tokenAddress,
                     ismAddress: expectedIsm,
                 })),
             });
         }
-        const currentHook = (0,dist_artifact/* artifactOnChainToAddress */.wM)(current.config.hook, normalizeStarknetAddressSafe);
-        const expectedHook = (0,dist_artifact/* artifactOnChainToAddress */.wM)(expectedConfig.hook, normalizeStarknetAddressSafe);
+        const currentHook = (0,dist_artifact/* artifactOnChainToAddress */.wM)(current.config.hook, contracts_normalizeStarknetAddressSafe);
+        const expectedHook = (0,dist_artifact/* artifactOnChainToAddress */.wM)(expectedConfig.hook, contracts_normalizeStarknetAddressSafe);
         if (!(0,addresses/* eqAddressStarknet */.PD)(currentHook ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx, expectedHook ?? addresses/* ZERO_ADDRESS_HEX_32 */.qx)) {
             txs.push({
                 annotation: 'Setting warp token hook',
-                ...(await this.signer.getSetTokenHookTransaction({
-                    signer: this.signer.getSignerAddress(),
+                ...(await getSetTokenHookTx(this.provider.getRawProvider(), {
                     tokenAddress,
                     hookAddress: expectedHook,
                 })),
@@ -2724,8 +2454,7 @@ class StarknetWarpTokenWriterBase extends StarknetWarpTokenReaderBase {
         for (const domain of routerUpdates.toUnenroll.sort((a, b) => a - b)) {
             txs.push({
                 annotation: `Unenrolling remote router for domain ${domain}`,
-                ...(await this.signer.getUnenrollRemoteRouterTransaction({
-                    signer: this.signer.getSignerAddress(),
+                ...(await getUnenrollRemoteRouterTx(this.provider.getRawProvider(), {
                     tokenAddress,
                     receiverDomainId: domain,
                 })),
@@ -2734,8 +2463,7 @@ class StarknetWarpTokenWriterBase extends StarknetWarpTokenReaderBase {
         for (const route of routerUpdates.toEnroll.sort((a, b) => a.domainId - b.domainId)) {
             txs.push({
                 annotation: `Enrolling remote router for domain ${route.domainId}`,
-                ...(await this.signer.getEnrollRemoteRouterTransaction({
-                    signer: this.signer.getSignerAddress(),
+                ...(await getEnrollRemoteRouterTx(this.provider.getRawProvider(), {
                     tokenAddress,
                     remoteRouter: {
                         receiverDomainId: route.domainId,
@@ -2751,15 +2479,15 @@ class StarknetWarpTokenWriterBase extends StarknetWarpTokenReaderBase {
         return txs;
     }
     preserveUnsetHookAndIsm(current, expected) {
-        const expectedIsm = (0,dist_artifact/* artifactOnChainToAddress */.wM)(expected.interchainSecurityModule, normalizeStarknetAddressSafe);
-        const expectedHook = (0,dist_artifact/* artifactOnChainToAddress */.wM)(expected.hook, normalizeStarknetAddressSafe);
+        const expectedIsm = (0,dist_artifact/* artifactOnChainToAddress */.wM)(expected.interchainSecurityModule, contracts_normalizeStarknetAddressSafe);
+        const expectedHook = (0,dist_artifact/* artifactOnChainToAddress */.wM)(expected.hook, contracts_normalizeStarknetAddressSafe);
         return {
             ...expected,
             interchainSecurityModule: (0,addresses/* isEmptyAddress */.Ae)(expectedIsm)
-                ? (0,dist_artifact/* addressToUnderivedArtifact */.Se)((0,dist_artifact/* artifactOnChainToAddress */.wM)(current.interchainSecurityModule, normalizeStarknetAddressSafe))
+                ? (0,dist_artifact/* addressToUnderivedArtifact */.Se)((0,dist_artifact/* artifactOnChainToAddress */.wM)(current.interchainSecurityModule, contracts_normalizeStarknetAddressSafe))
                 : expected.interchainSecurityModule,
             hook: (0,addresses/* isEmptyAddress */.Ae)(expectedHook)
-                ? (0,dist_artifact/* addressToUnderivedArtifact */.Se)((0,dist_artifact/* artifactOnChainToAddress */.wM)(current.hook, normalizeStarknetAddressSafe))
+                ? (0,dist_artifact/* addressToUnderivedArtifact */.Se)((0,dist_artifact/* artifactOnChainToAddress */.wM)(current.hook, contracts_normalizeStarknetAddressSafe))
                 : expected.hook,
         };
     }
@@ -2771,19 +2499,17 @@ class StarknetWarpTokenWriterBase extends StarknetWarpTokenReaderBase {
     async applyPostCreateConfig(tokenAddress, expected, current) {
         const receipts = [];
         let ownerTx;
-        const expectedIsm = (0,dist_artifact/* artifactOnChainToAddress */.wM)(expected.interchainSecurityModule, normalizeStarknetAddressSafe);
+        const expectedIsm = (0,dist_artifact/* artifactOnChainToAddress */.wM)(expected.interchainSecurityModule, contracts_normalizeStarknetAddressSafe);
         if (expectedIsm) {
-            const tx = await this.signer.getSetTokenIsmTransaction({
-                signer: this.signer.getSignerAddress(),
+            const tx = await getSetTokenIsmTx(this.provider.getRawProvider(), {
                 tokenAddress,
                 ismAddress: expectedIsm,
             });
             receipts.push(await this.signer.sendAndConfirmTransaction(tx));
         }
-        const expectedHook = (0,dist_artifact/* artifactOnChainToAddress */.wM)(expected.hook, normalizeStarknetAddressSafe);
+        const expectedHook = (0,dist_artifact/* artifactOnChainToAddress */.wM)(expected.hook, contracts_normalizeStarknetAddressSafe);
         if (expectedHook) {
-            const tx = await this.signer.getSetTokenHookTransaction({
-                signer: this.signer.getSignerAddress(),
+            const tx = await getSetTokenHookTx(this.provider.getRawProvider(), {
                 tokenAddress,
                 hookAddress: expectedHook,
             });
@@ -2794,8 +2520,7 @@ class StarknetWarpTokenWriterBase extends StarknetWarpTokenReaderBase {
             .sort((a, b) => a - b)) {
             const remoteRouter = expected.remoteRouters[domain];
             (0,validation/* assert */.v)(remoteRouter, `Missing remote router for Starknet domain ${domain}`);
-            const tx = await this.signer.getEnrollRemoteRouterTransaction({
-                signer: this.signer.getSignerAddress(),
+            const tx = await getEnrollRemoteRouterTx(this.provider.getRawProvider(), {
                 tokenAddress,
                 remoteRouter: {
                     receiverDomainId: domain,
@@ -2807,8 +2532,7 @@ class StarknetWarpTokenWriterBase extends StarknetWarpTokenReaderBase {
         }
         const currentOwner = current.owner;
         if (!(0,addresses/* eqAddressStarknet */.PD)(currentOwner, expected.owner)) {
-            ownerTx = await this.signer.getSetTokenOwnerTransaction({
-                signer: this.signer.getSignerAddress(),
+            ownerTx = await getSetTokenOwnerTx(this.provider.getRawProvider(), {
                 tokenAddress,
                 newOwner: expected.owner,
             });
@@ -2825,13 +2549,15 @@ class StarknetWarpTokenWriterBase extends StarknetWarpTokenReaderBase {
 
 
 
+
+
 class StarknetCollateralTokenReader extends StarknetWarpTokenReaderBase {
     tokenType = 'collateral';
     toConfig(token, remoteRouters) {
         return {
             type: warp/* TokenType */.ks.collateral,
             ...this.baseConfig(token, remoteRouters),
-            token: normalizeStarknetAddressSafe(token.denom),
+            token: contracts_normalizeStarknetAddressSafe(token.denom),
             name: token.name,
             symbol: token.symbol,
             decimals: token.decimals,
@@ -2844,17 +2570,19 @@ class StarknetCollateralTokenWriter extends StarknetWarpTokenWriterBase {
         return {
             type: warp/* TokenType */.ks.collateral,
             ...this.baseConfig(token, remoteRouters),
-            token: normalizeStarknetAddressSafe(token.denom),
+            token: contracts_normalizeStarknetAddressSafe(token.denom),
             name: token.name,
             symbol: token.symbol,
             decimals: token.decimals,
         };
     }
     async createToken(artifact) {
-        const tx = await this.signer.getCreateCollateralTokenTransaction({
-            signer: this.signer.getSignerAddress(),
+        const mailbox = await getMailboxConfig(this.provider.getRawProvider(), artifact.config.mailbox);
+        const tx = getCreateCollateralTokenTx(this.signer.getSignerAddress(), {
             mailboxAddress: artifact.config.mailbox,
             collateralDenom: artifact.config.token,
+            defaultHook: mailbox.defaultHook,
+            defaultIsm: mailbox.defaultIsm,
         });
         return this.signer.sendAndConfirmTransaction(tx);
     }
@@ -2867,6 +2595,8 @@ class StarknetCollateralTokenWriter extends StarknetWarpTokenWriterBase {
 ;// CONCATENATED MODULE: ../starknet-sdk/dist/warp/native-token-artifact-manager.js
 
 
+
+
 class StarknetNativeTokenReader extends StarknetWarpTokenReaderBase {
     tokenType = 'native';
     toConfig(token, remoteRouters) {
@@ -2885,9 +2615,12 @@ class StarknetNativeTokenWriter extends StarknetWarpTokenWriterBase {
         };
     }
     async createToken(artifact) {
-        const tx = await this.signer.getCreateNativeTokenTransaction({
-            signer: this.signer.getSignerAddress(),
+        const mailbox = await getMailboxConfig(this.provider.getRawProvider(), artifact.config.mailbox);
+        const tx = getCreateNativeTokenTx(this.signer.getSignerAddress(), {
             mailboxAddress: artifact.config.mailbox,
+            feeTokenAddress: this.provider.getFeeTokenAddress(),
+            defaultHook: mailbox.defaultHook,
+            defaultIsm: mailbox.defaultIsm,
         });
         return this.signer.sendAndConfirmTransaction(tx);
     }
@@ -2897,6 +2630,8 @@ class StarknetNativeTokenWriter extends StarknetWarpTokenWriterBase {
 
 
 
+
+
 class StarknetSyntheticTokenReader extends StarknetWarpTokenReaderBase {
     tokenType = 'synthetic';
     toConfig(token, remoteRouters) {
@@ -2932,12 +2667,14 @@ class StarknetSyntheticTokenWriter extends StarknetWarpTokenWriterBase {
         (0,validation/* assert */.v)(!expected.metadataUri, 'metadataUri is unsupported for Starknet synthetic warp tokens');
     }
     async createToken(artifact) {
-        const tx = await this.signer.getCreateSyntheticTokenTransaction({
-            signer: this.signer.getSignerAddress(),
+        const mailbox = await getMailboxConfig(this.provider.getRawProvider(), artifact.config.mailbox);
+        const tx = getCreateSyntheticTokenTx(this.signer.getSignerAddress(), {
             mailboxAddress: artifact.config.mailbox,
             name: artifact.config.name,
             denom: artifact.config.symbol,
             decimals: artifact.config.decimals,
+            defaultHook: mailbox.defaultHook,
+            defaultIsm: mailbox.defaultIsm,
         });
         return this.signer.sendAndConfirmTransaction(tx);
     }