You tell it where you put your code. You picked some free space, right? Where did you put your code? Take that address and put it in the jump statement. And yeah, if you've left the bank, you will have to swap banks.

Depends on the mapper.

MMC1 is frustrating. I'll just give the program-ROM switching part, since that's what you're interested in.
MMC1 can use 16KB banks (most common) or 32KB (haven't seen it before).

To change a register for MMC1, you have to write a 5-bit value to any value within a certain address range (the last byte of the range seems to be most common). Also, you must write each bit seperately.
You'll probably use just the $E000-FFFF range (which swaps PRG banks).
To write the 5-bit value
LDA $value (actually, it seems you can only use a 4-bit value (00-0F), for a total of 16 banks. Bit 5 seems to be undefined)
STA $offset: LSR (repeat this sequence 4 times)
STA $offset
since this space-wasting code, the game likely has a function to do it in the last program ROM bank (since it's always located at CPU address $C000-FFFF). Search a trace log for writes to $FFFF (can't recall if that was the address used, but it's the most likely).
Remember that if you begin your code from the $8000 to $BFFF range, the bank will have swapped when you return. So you'll need to continue your code from the corresponding address in the new bank.
Make sense?

Maybe I should give an example.

EDITED: Because I made a minor mistake in the last step.

Say I'm at $1BFF0 in the ROM file (minus the header, it's $1BFE0). $1BFE0 (rom offset) mod $4000 (bank size)= $3FE0. I need to remember that.
I have this code, and it's at CPU address $BFE0: (because $8000 + the $3FE0 from above = $BFE0)
LDA #$bank_number
JSR $C474 (I just checked a trace log. This is where the game's original bankswap routine is, CPU address $C000-FFFF is locked to the last 16KB of program ROM, so this should be $1C484 if STED has 128KB PRG. The routine assumes that the accumulator holds the value to swap.).
So, anyway, now my code is 5 bytes long (2 byte LDA, 3 byte JSR).
But while I was running the routine in the $C000-FFFF region of the CPU, the contents of $8000-BFFF changed.
The game is going to run whatever code is now at CPU address $BFE5.
So I'm going to need to continue my code at ROM offset: (bank_number) * $4000 + $3FE0 (from the first step of this example) + 5 (because I used 5 bytes for LDA and JSR instructions) + $10 (the header)

So... what is happening at the point of execution where it should jump to your code? That's what the debugging process is. You make a change, if it doesn't work, see what is happening and figure out why it's not doing what you intend. So, the next step is to figure out what the game is doing and why it's not going to your code by looking at the trace log. You've given us no information to go on other than it doesn't crash the game, but your code isn't being executed. We can't do much of anything with that little to go on.

A log of the few instructions where your code should be executed through your code's execution to the return from it if it gets that far. Perhaps you're still not grasping this.

The ROM code executes normally to the code spot you changed. WHAT is happening when it gets to that point? The trace log of those instructions will tell you exactly that. The first instruction is obviously going to be a jump or a jump to subroutine instruction. Then it should go to the new place in code your new code is waiting. It will execute that code, then it will return back to the normally executing game code.

It's pretty simple. A log of those few instructions will tell you everything that is happening. Analyzing that tells you what is wrong and why it's not doing what you expect it to do.

But you MUST look at code that's being executed. That's debugging on a fundamental level. See what the code is doing. Based on that, figure out why it is not doing what you expect it to do.

You should use FCEUltra XD SP's trace logger.
Press F2 to pause the emulator just before buying something. (like when you have the cursor pointing to the item)
Open the trace logger.
I'd choose to log to a file. Enter a file name.
Begin the trace logger.
Press F2 to unpause the emulator, then press the "A" button to buy the item.
When your credits change or the game crashes, stop the trace logger.
Close the emulator and check your trace log.