You can achieve this by pegging assets across chains requires locking tokens on chain A and minting synthetic representations on chain B. Attack surface: relay tampering, double-spend, replay attacks, and validator-set changes. Move packages must implement robust verification of cross-chain proofs.

Strategy

1. Use light-client proofs: the target chain must verify a proof (header + merkle inclusion) that some on-chain event occurred on source chain.
2. Store nonce/txid of processed messages on target chain to prevent replays.
3. Require relayer signatures or an on-chain light client that validates source chain finality (e.g., a simplified BTC/SPV style Merkle proof or an Aptos/Sui header proof).
4. Use linearity: only mint when a valid, unused proof is submitted; burn on target chain when unlocking is requested back on source chain.

High-level Move sketch (target chain side)

module 0xA::peg_mint {
    use std::signer;
    use std::vector;

    // Synthetic token minted on this chain
    struct Synth has store, drop { value: u128 }

    // Record of processed source-chain events to prevent replay
    struct Processed has key {
        seen: vector<vector<u8>> // store proof ids or tx hashes
    }

    // Admin / light-client root (simplified)
    struct LightClient has key {
        // root or validator set checkpoint — in production this is more complex
        checkpoint_root: vector<u8>
    }

    public fun init(admin: &signer, checkpoint_root: vector<u8>) {
        move_to(admin, LightClient { checkpoint_root });
        move_to(admin, Processed { seen: vector::empty() });
    }

    // Accept a proof (serialized) that a `Lock` event occurred on source chain.
    // The relayer provides proof bytes; the contract verifies via `verify_proof`.
    public fun redeem_locked_tokens(relayer: &signer, proof: vector<u8>, expected_amount: u128, recipient: address) acquires LightClient, Processed {
        let lc = borrow_global<LightClient>(signer::address_of(relayer));
        // Verify proof against light client checkpoint
        let (ok, proof_id) = verify_proof(&lc.checkpoint_root, &proof);
        assert!(ok, 1);

        // Ensure not processed before
        let proc = borrow_global_mut<Processed>(signer::address_of(relayer));
        assert!(!contains(&proc.seen, &proof_id), 2);

        // Mark processed
        vector::push_back(&mut proc.seen, proof_id);

        // Mint synth to recipient
        move_to(&create_temp_signer(), Synth { value: expected_amount });
        // In practice you'd credit recipient's balance resource rather than move_to a temp signer.
    }

    // Proof verification placeholder (must be implemented by chain-specific verifier)
    fun verify_proof(checkpoint: &vector<u8>, proof: &vector<u8>): (bool, vector<u8>) {
        // parse proof, check merkle inclusion against checkpoint, check event type == "Lock" and read fields
        // return (is_valid, proof_id)
        (true, vector::empty())
    }

    fun contains(v: &vector<vector<u8>>, item: &vector<u8>): bool {
        let len = vector::length(v);
        let i = 0;
        while (i < len) {
            if (vector::borrow(v, i) == item) { return true; }
            i = i + 1;
        }
        false
    }

    fun create_temp_signer(): signer {
        // placeholder — in practice minting/sending needs chain-specific mechanics
        // Many chains require actual signers to move resources into accounts.
        abort 999
    }
}

Security & practical notes

• Light client complexity: true light-client verification requires verifying source chain headers and signatures (validator sets). For EVM-like chains, you verify Merkle proofs of receipts; for Aptos/Sui you verify certified transaction effects against a checkpoint signed by validators.

• Finality assumptions: only accept proofs after sufficient finality (e.g., N confirmations or a checkpoint signed by consensus) to avoid reorg exploits.

• Relay trust model:

  • Minimal trust: fully on-chain light client that can verify validator signatures and slashing; complex but safest.
  • Practical compromise: federated relayer set with multi-sig attestation; faster but requires trusting the relayer quorum.

• Replay protection: storing processed proof IDs on target chain prevents replay. Use cryptographic tx hash + log index as proof id.

• Economic safeguards: require over-collateralization, or allow emergency pause by governance if an exploit is detected.

Implementation variants

• For Sui→Aptos: Sui objects/events are included in transaction effects; you must consume a proof of object mutation (object deletion/transfer). Aptos verifier must validate certified ledger info and transaction proofs.
• For EVM→Move: verify a transaction receipt Merkle proof using a trusted block header; the Move module must contain code to validate Ethereum signatures or accept a trusted block header root from a checkpointing oracle.