@humanode-hyperlane/starknet-sdk 0.0.0-stage → 27.2.3-humanode.1

package/dist/clients/provider.js

@@ -0,0 +1,746 @@
+import { CairoOption, CairoOptionVariant, RpcProvider, hash, shortString, } from 'starknet';
+import { AltVM } from '@humanode-hyperlane/provider-sdk';
+import { ContractType, getCompiledContract, } from '@humanode-hyperlane/starknet-core';
+import { ZERO_ADDRESS_HEX_32, addressToBytes32, assert, ensure0x, isZeroishAddress, } from '@humanode-hyperlane/utils';
+import { StarknetContractName, addressToEvmAddress, callContract, extractEnumVariant, getFeeTokenAddress, getOnChainStarknetContract, getStarknetContract, normalizeRoutersAddress, normalizeStarknetAddressSafe, populateInvokeTx, toBigInt, toNumber, } from '../contracts.js';
+let tokenTypeByClassHash;
+function getTokenTypeByClassHash() {
+    if (tokenTypeByClassHash) {
+        return tokenTypeByClassHash;
+    }
+    const entries = [
+        [
+            hash.computeContractClassHash(getCompiledContract(StarknetContractName.HYP_ERC20, ContractType.TOKEN)),
+            AltVM.TokenType.synthetic,
+        ],
+        [
+            hash.computeContractClassHash(getCompiledContract(StarknetContractName.HYP_ERC20_COLLATERAL, ContractType.TOKEN)),
+            AltVM.TokenType.collateral,
+        ],
+        [
+            hash.computeContractClassHash(getCompiledContract(StarknetContractName.HYP_NATIVE, ContractType.TOKEN)),
+            AltVM.TokenType.native,
+        ],
+    ];
+    tokenTypeByClassHash = new Map(entries.map(([classHash, tokenType]) => [
+        BigInt(classHash).toString(),
+        tokenType,
+    ]));
+    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));
+}
+export class StarknetProvider {
+    provider;
+    metadata;
+    rpcUrls;
+    static connect(rpcUrls, _chainId, extraParams) {
+        assert(extraParams?.metadata, 'metadata missing for Starknet provider');
+        const metadata = extraParams.metadata;
+        assert(rpcUrls.length > 0, 'at least one rpc url is required');
+        const provider = new RpcProvider({ nodeUrl: rpcUrls[0] });
+        return new StarknetProvider(provider, metadata, rpcUrls);
+    }
+    constructor(provider, metadata, rpcUrls) {
+        this.provider = provider;
+        this.metadata = metadata;
+        this.rpcUrls = rpcUrls;
+    }
+    getRawProvider() {
+        return this.provider;
+    }
+    withContract(name, address, providerOrAccount, contractType) {
+        return getStarknetContract(name, address, providerOrAccount ?? this.provider, contractType);
+    }
+    get accountAddress() {
+        throw new Error('StarknetProvider has no signer account');
+    }
+    get feeTokenAddress() {
+        return getFeeTokenAddress({
+            chainName: this.metadata.name,
+            nativeDenom: this.metadata.nativeToken?.denom,
+        });
+    }
+    parseString(value) {
+        if (typeof value === 'string')
+            return value;
+        if (typeof value === 'number' || typeof value === 'bigint') {
+            try {
+                return shortString.decodeShortString(ensure0x(BigInt(value).toString(16)));
+            }
+            catch {
+                return value.toString();
+            }
+        }
+        if (value && typeof value === 'object') {
+            if ('value' in value)
+                return this.parseString(value.value);
+            const toStringFn = Reflect.get(value, 'toString');
+            if (typeof toStringFn === 'function' &&
+                toStringFn !== Object.prototype.toString) {
+                const parsed = Reflect.apply(toStringFn, value, []);
+                if (typeof parsed === 'string' && parsed !== '[object Object]') {
+                    return parsed;
+                }
+            }
+        }
+        return '';
+    }
+    async populateInvokeCall(contract, method, args = []) {
+        const tx = await populateInvokeTx(contract, method, args);
+        assert(tx.kind === 'invoke', 'Expected invoke Starknet transaction');
+        return {
+            contractAddress: normalizeStarknetAddressSafe(tx.contractAddress),
+            entrypoint: tx.entrypoint,
+            calldata: tx.calldata,
+        };
+    }
+    unwrapBalance(value) {
+        if (value && typeof value === 'object' && 'balance' in value) {
+            return value.balance;
+        }
+        return value;
+    }
+    async determineTokenType(tokenAddress) {
+        const address = normalizeStarknetAddressSafe(tokenAddress);
+        const classHash = await this.provider.getClassHashAt(address);
+        const tokenType = getTokenTypeByClassHash().get(BigInt(classHash).toString());
+        if (tokenType)
+            return tokenType;
+        try {
+            const collateral = this.withContract(StarknetContractName.HYP_ERC20_COLLATERAL, address, this.provider, ContractType.TOKEN);
+            await callContract(collateral, 'get_wrapped_token');
+            return AltVM.TokenType.collateral;
+        }
+        catch (error) {
+            if (!isProbeMiss(error))
+                throw error;
+        }
+        try {
+            const native = this.withContract(StarknetContractName.HYP_NATIVE, address, this.provider, ContractType.TOKEN);
+            await callContract(native, 'native_token');
+            return AltVM.TokenType.native;
+        }
+        catch (error) {
+            if (!isProbeMiss(error))
+                throw error;
+        }
+        return AltVM.TokenType.synthetic;
+    }
+    /**
+     * Reads ERC20 metadata by fetching the contract's own ABI from chain,
+     * so starknet.js parses responses correctly regardless of whether
+     * the contract uses felt252 (Cairo 0) or ByteArray (Cairo 1).
+     */
+    async getTokenMetadata(tokenAddress) {
+        const nativeToken = this.metadata.nativeToken;
+        if (nativeToken?.denom &&
+            normalizeStarknetAddressSafe(tokenAddress) ===
+                normalizeStarknetAddressSafe(nativeToken.denom)) {
+            return {
+                name: nativeToken.name,
+                symbol: nativeToken.symbol,
+                decimals: nativeToken.decimals ?? 18,
+            };
+        }
+        const address = normalizeStarknetAddressSafe(tokenAddress);
+        const token = await getOnChainStarknetContract(this.provider, address);
+        const [name, symbol, decimals] = await Promise.all([
+            callContract(token, 'name'),
+            callContract(token, 'symbol'),
+            callContract(token, 'decimals'),
+        ]);
+        return {
+            name: this.parseString(name),
+            symbol: this.parseString(symbol),
+            decimals: toNumber(decimals),
+        };
+    }
+    parseHookVariant(variant) {
+        const upper = variant.toUpperCase();
+        if (upper.includes('MERKLE_TREE'))
+            return AltVM.HookType.MERKLE_TREE;
+        if (upper.includes('PROTOCOL_FEE'))
+            return AltVM.HookType.PROTOCOL_FEE;
+        if (upper.includes('INTERCHAIN_GAS_PAYMASTER')) {
+            return AltVM.HookType.INTERCHAIN_GAS_PAYMASTER;
+        }
+        return AltVM.HookType.CUSTOM;
+    }
+    parseIsmVariant(variant) {
+        const upper = variant.toUpperCase();
+        if (upper.includes('TEST') ||
+            upper.includes('NOOP') ||
+            upper.includes('NULL') ||
+            upper.includes('UNUSED')) {
+            return AltVM.IsmType.TEST_ISM;
+        }
+        if (upper.includes('MERKLE_ROOT_MULTISIG')) {
+            return AltVM.IsmType.MERKLE_ROOT_MULTISIG;
+        }
+        if (upper.includes('MESSAGE_ID_MULTISIG')) {
+            return AltVM.IsmType.MESSAGE_ID_MULTISIG;
+        }
+        if (upper.includes('ROUTING')) {
+            return AltVM.IsmType.ROUTING;
+        }
+        return AltVM.IsmType.CUSTOM;
+    }
+    // ### QUERY BASE ###
+    async isHealthy() {
+        try {
+            await this.provider.getBlockNumber();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getRpcUrls() {
+        return this.rpcUrls;
+    }
+    async getHeight() {
+        return this.provider.getBlockNumber();
+    }
+    async getBalance(req) {
+        const tokenAddress = req.denom
+            ? normalizeStarknetAddressSafe(req.denom)
+            : this.feeTokenAddress;
+        const token = this.withContract(StarknetContractName.ETHER, tokenAddress, this.provider, ContractType.TOKEN);
+        let balance;
+        try {
+            balance = await callContract(token, 'balanceOf', [
+                normalizeStarknetAddressSafe(req.address),
+            ]);
+        }
+        catch (error) {
+            if (!isProbeMiss(error))
+                throw error;
+            balance = await callContract(token, 'balance_of', [
+                normalizeStarknetAddressSafe(req.address),
+            ]);
+        }
+        return toBigInt(this.unwrapBalance(balance));
+    }
+    async getTotalSupply(req) {
+        const tokenAddress = req.denom
+            ? normalizeStarknetAddressSafe(req.denom)
+            : this.feeTokenAddress;
+        const token = this.withContract(StarknetContractName.ETHER, tokenAddress, this.provider, ContractType.TOKEN);
+        return toBigInt(await callContract(token, 'total_supply'));
+    }
+    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 AltVM.IsmType.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'),
+        ]);
+        assert(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'),
+        ]);
+        assert(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'),
+        ]);
+        assert(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 AltVM.HookType.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) };
+    }
+    // ### QUERY WARP ###
+    async getToken(req) {
+        const tokenAddress = normalizeStarknetAddressSafe(req.tokenAddress);
+        const token = this.withContract(StarknetContractName.HYP_ERC20, tokenAddress, this.provider, ContractType.TOKEN);
+        const tokenType = await this.determineTokenType(tokenAddress);
+        const [owner, mailboxAddress, ismAddress, hookAddress] = await Promise.all([
+            callContract(token, 'owner'),
+            callContract(token, 'mailbox'),
+            callContract(token, 'interchain_security_module'),
+            callContract(token, 'get_hook'),
+        ]);
+        let denom = tokenAddress;
+        let name = '';
+        let symbol = '';
+        let decimals = this.metadata.nativeToken?.decimals ?? 18;
+        try {
+            const metadata = await this.getTokenMetadata(tokenAddress);
+            name = metadata.name;
+            symbol = metadata.symbol;
+            decimals = metadata.decimals;
+        }
+        catch (error) {
+            if (!isProbeMiss(error))
+                throw error;
+        }
+        if (tokenType === AltVM.TokenType.collateral) {
+            const collateral = this.withContract(StarknetContractName.HYP_ERC20_COLLATERAL, tokenAddress, this.provider, ContractType.TOKEN);
+            const wrapped = await callContract(collateral, 'get_wrapped_token');
+            denom = normalizeStarknetAddressSafe(wrapped);
+            try {
+                const wrappedMeta = await this.getTokenMetadata(denom);
+                name = wrappedMeta.name;
+                symbol = wrappedMeta.symbol;
+                decimals = wrappedMeta.decimals;
+            }
+            catch (error) {
+                if (!isProbeMiss(error))
+                    throw error;
+            }
+        }
+        else if (tokenType === AltVM.TokenType.native) {
+            const native = this.withContract(StarknetContractName.HYP_NATIVE, tokenAddress, this.provider, ContractType.TOKEN);
+            try {
+                const nativeTokenAddress = await callContract(native, 'native_token');
+                denom = normalizeStarknetAddressSafe(nativeTokenAddress);
+            }
+            catch (error) {
+                if (!isProbeMiss(error))
+                    throw error;
+                denom = this.metadata.nativeToken?.denom ?? this.feeTokenAddress;
+            }
+            name = this.metadata.nativeToken?.name ?? name;
+            symbol = this.metadata.nativeToken?.symbol ?? symbol;
+            decimals = this.metadata.nativeToken?.decimals ?? decimals;
+        }
+        return {
+            address: tokenAddress,
+            owner: normalizeStarknetAddressSafe(owner),
+            tokenType,
+            mailboxAddress: normalizeStarknetAddressSafe(mailboxAddress),
+            ismAddress: normalizeStarknetAddressSafe(ismAddress),
+            hookAddress: normalizeStarknetAddressSafe(hookAddress),
+            denom,
+            name,
+            symbol,
+            decimals,
+        };
+    }
+    async getRemoteRouters(req) {
+        const token = this.withContract(StarknetContractName.HYP_ERC20, req.tokenAddress, this.provider, ContractType.TOKEN);
+        const domains = await callContract(token, 'domains');
+        assert(Array.isArray(domains), 'Expected Starknet token domains array');
+        const remoteRouters = await Promise.all(domains.map(async (domainId) => {
+            const domain = toNumber(domainId);
+            const [routerAddress, gas] = await Promise.all([
+                callContract(token, 'routers', [domainId]),
+                callContract(token, 'destination_gas', [domainId]).catch(() => 0),
+            ]);
+            return {
+                receiverDomainId: domain,
+                receiverAddress: normalizeRoutersAddress(routerAddress),
+                gas: toBigInt(gas).toString(),
+            };
+        }));
+        return {
+            address: normalizeStarknetAddressSafe(req.tokenAddress),
+            remoteRouters,
+        };
+    }
+    async getBridgedSupply(req) {
+        const tokenInfo = await this.getToken({ tokenAddress: req.tokenAddress });
+        const token = this.withContract(StarknetContractName.HYP_ERC20, req.tokenAddress, this.provider, ContractType.TOKEN);
+        if (tokenInfo.tokenType === AltVM.TokenType.synthetic) {
+            return toBigInt(await callContract(token, 'total_supply'));
+        }
+        return this.getBalance({
+            address: req.tokenAddress,
+            denom: tokenInfo.denom,
+        });
+    }
+    async quoteRemoteTransfer(req) {
+        const token = this.withContract(StarknetContractName.HYP_ERC20, req.tokenAddress, this.provider, ContractType.TOKEN);
+        const quote = await callContract(token, 'quote_gas_payment', [
+            req.destinationDomainId,
+        ]);
+        return {
+            denom: this.feeTokenAddress,
+            amount: toBigInt(quote),
+        };
+    }
+    // ### GET CORE TXS ###
+    async getCreateMailboxTransaction(req) {
+        return {
+            kind: 'deploy',
+            contractName: StarknetContractName.MAILBOX,
+            constructorArgs: [
+                req.domainId,
+                normalizeStarknetAddressSafe(req.signer),
+                normalizeStarknetAddressSafe(req.defaultIsmAddress ?? ZERO_ADDRESS_HEX_32),
+                normalizeStarknetAddressSafe(req.defaultHookAddress ?? ZERO_ADDRESS_HEX_32),
+                normalizeStarknetAddressSafe(req.requiredHookAddress ?? ZERO_ADDRESS_HEX_32),
+            ],
+        };
+    }
+    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) => addressToBytes32(validator)),
+                req.threshold,
+            ],
+        };
+    }
+    async getCreateMessageIdMultisigIsmTransaction(req) {
+        return {
+            kind: 'deploy',
+            contractName: StarknetContractName.MESSAGE_ID_MULTISIG_ISM,
+            constructorArgs: [
+                normalizeStarknetAddressSafe(req.signer),
+                req.validators.map((validator) => addressToBytes32(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: ContractType.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: ContractType.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: ContractType.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, ContractType.TOKEN);
+        return populateInvokeTx(token, 'transfer_ownership', [
+            normalizeStarknetAddressSafe(req.newOwner),
+        ]);
+    }
+    async getSetTokenIsmTransaction(req) {
+        const token = this.withContract(StarknetContractName.HYP_ERC20, req.tokenAddress, this.provider, ContractType.TOKEN);
+        return populateInvokeTx(token, 'set_interchain_security_module', [
+            normalizeStarknetAddressSafe(req.ismAddress ?? ZERO_ADDRESS_HEX_32),
+        ]);
+    }
+    async getSetTokenHookTransaction(req) {
+        const token = this.withContract(StarknetContractName.HYP_ERC20, req.tokenAddress, this.provider, ContractType.TOKEN);
+        return populateInvokeTx(token, 'set_hook', [
+            normalizeStarknetAddressSafe(req.hookAddress ?? ZERO_ADDRESS_HEX_32),
+        ]);
+    }
+    async getEnrollRemoteRouterTransaction(req) {
+        const token = this.withContract(StarknetContractName.HYP_ERC20, req.tokenAddress, this.provider, ContractType.TOKEN);
+        const receiverAddress = isZeroishAddress(req.remoteRouter.receiverAddress)
+            ? ZERO_ADDRESS_HEX_32
+            : ensure0x(req.remoteRouter.receiverAddress);
+        const noneOption = new CairoOption(CairoOptionVariant.None);
+        const domainOption = new CairoOption(CairoOptionVariant.Some, req.remoteRouter.receiverDomainId);
+        const gasOption = new CairoOption(CairoOptionVariant.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, ContractType.TOKEN);
+        return populateInvokeTx(token, 'unenroll_remote_router', [
+            req.receiverDomainId,
+        ]);
+    }
+    async getTransferTransaction(req) {
+        const denom = req.denom
+            ? normalizeStarknetAddressSafe(req.denom)
+            : this.feeTokenAddress;
+        const token = this.withContract(StarknetContractName.ETHER, denom, this.provider, ContractType.TOKEN);
+        return populateInvokeTx(token, 'transfer', [
+            normalizeStarknetAddressSafe(req.recipient),
+            req.amount,
+        ]);
+    }
+    async getRemoteTransferTransaction(req) {
+        return this.buildRemoteTransferTransaction(req);
+    }
+    async buildRemoteTransferTransaction(req, tokenInfo) {
+        if (req.customHookAddress || req.customHookMetadata) {
+            throw new Error('Custom hook metadata/addresses are unsupported for Starknet transfer_remote in provider-sdk');
+        }
+        const tokenType = tokenInfo?.tokenType ?? (await this.determineTokenType(req.tokenAddress));
+        const token = this.withContract(StarknetContractName.HYP_ERC20, req.tokenAddress, this.provider, ContractType.TOKEN);
+        const noneOption = new CairoOption(CairoOptionVariant.None);
+        let value;
+        if (tokenType === AltVM.TokenType.native) {
+            value = toBigInt(req.amount) + toBigInt(req.maxFee.amount);
+        }
+        else if (tokenType === AltVM.TokenType.collateral) {
+            value = toBigInt(req.maxFee.amount);
+        }
+        else {
+            value = toBigInt(req.maxFee.amount);
+        }
+        return populateInvokeTx(token, 'transfer_remote', [
+            req.destinationDomainId,
+            addressToBytes32(req.recipient),
+            req.amount,
+            value,
+            noneOption,
+            noneOption,
+        ]);
+    }
+}
+//# sourceMappingURL=provider.js.map