"""Offline, deliberately limited PSBT v0 exercise; no networking or wallet access."""
import base64,io,json,struct

def compact(n):
 if not 0<=n<253:raise ValueError("fixture length out of range")
 return bytes([n])
def blob(b):return compact(len(b))+b
def item(k,v):return blob(k)+blob(v)
def script(byte):return bytes.fromhex("0014")+bytes([byte])*20
def output(value,byte):return struct.pack("<Q",value)+blob(script(byte))
def fixture(recipient=90000,claimed_input=100000):
 tx=struct.pack("<I",2)+b"\x01"+b"\x11"*32+struct.pack("<I",0)+b"\x00"+struct.pack("<I",0xfffffffd)+b"\x02"+output(recipient,0x22)+output(5000,0x44)+struct.pack("<I",0)
 return b"psbt\xff"+item(b"\x00",tx)+b"\x00"+item(b"\x01",output(claimed_input,0x33))+b"\x00"+b"\x00\x00"
def read(s,n):
 b=s.read(n)
 if len(b)!=n:raise ValueError("truncated")
 return b
def size(s):
 n=read(s,1)[0]
 if n>=253:raise ValueError("this exercise only supports short CompactSize values")
 return n
def var(s):return read(s,size(s))
def mapping(s):
 result={}
 while True:
  k=var(s)
  if not k:return result
  if k in result:raise ValueError("duplicate map key")
  result[k]=var(s)
def parse(data):
 s=io.BytesIO(data)
 if read(s,5)!=b"psbt\xff":raise ValueError("bad magic")
 g=mapping(s)
 if set(g)!={b"\x00"}:raise ValueError("exercise requires only global unsigned tx")
 tx=io.BytesIO(g[b"\x00"]);version=struct.unpack("<I",read(tx,4))[0]
 if size(tx)!=1:raise ValueError("exercise requires one input")
 prev=read(tx,32).hex();index=struct.unpack("<I",read(tx,4))[0]
 if var(tx):raise ValueError("unsigned input script must be empty")
 seq=struct.unpack("<I",read(tx,4))[0]
 count=size(tx)
 if count!=2:raise ValueError("exercise requires two outputs")
 values=[];scripts=[]
 for _ in range(count):
  values.append(struct.unpack("<Q",read(tx,8))[0]);scripts.append(var(tx).hex())
 lock=struct.unpack("<I",read(tx,4))[0]
 if tx.read():raise ValueError("unexpected unsigned transaction data")
 inp=mapping(s)
 if set(inp)!={b"\x01"}:raise ValueError("exercise requires only witness_utxo input metadata")
 u=io.BytesIO(inp[b"\x01"]);claimed=struct.unpack("<Q",read(u,8))[0];prevscript=var(u).hex()
 if u.read():raise ValueError("unexpected previous-output data")
 for _ in range(count):
  if mapping(s):raise ValueError("exercise expects empty output maps")
 if s.read():raise ValueError("trailing data")
 return dict(version=version,input_count=1,prevout_txid=prev,prevout_index=index,sequence=seq,locktime=lock,claimed_input_litoshis=claimed,claimed_previous_script=prevscript,output_litoshis=values,output_scripts=scripts,apparent_fee_litoshis=claimed-sum(values),signatures=0,scope="Synthetic parsing/arithmetic only; no real UTXO or signature validation; not a broadcast candidate.")
def calculate():
 return {name:parse(data) for name,data in [
  ("baseline",fixture()),("reduced_recipient",fixture(recipient=80000)),("untrusted_input_metadata",fixture(claimed_input=200000))]}
def check(rows):
 assert rows["baseline"]["output_litoshis"]==[90000,5000]
 assert rows["baseline"]["apparent_fee_litoshis"]==5000
 assert rows["reduced_recipient"]["apparent_fee_litoshis"]==15000
 assert rows["untrusted_input_metadata"]["apparent_fee_litoshis"]==105000
 assert all(x["signatures"]==0 and x["version"]==2 and x["locktime"]==0 for x in rows.values())
 for bad in [b"",b"other"+fixture()[5:],fixture()[:-1],fixture()+b"\x00"]:
  try:parse(bad)
  except ValueError:pass
  else:raise AssertionError("invalid fixture accepted")
 try:mapping(io.BytesIO(item(b"\x01",b"a")+item(b"\x01",b"b")+b"\x00"))
 except ValueError:pass
 else:raise AssertionError("duplicate map key accepted")
 assert 1000*2000==2000000 and 1000*1000==1000000
 assert 100000-90000-5000==5000
 assert 150-100==50
 assert 6000+3000+1000==10000
 return dict(psbt_variants=3,malformed_cases_rejected=5,arithmetic_models_checked=4)
if __name__=="__main__":
 rows=calculate();checks=check(rows)
 print(json.dumps(dict(checks=checks,cases=rows),indent=2))