amp-rust 0.0.9

A Rust client for the Blockstream AMP API, providing interfaces for asset management, user operations, and token handling on the Liquid Network.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

#!/usr/bin/env python3
"""
Script to find which GAID owns a specific address using the local mnemonics.
"""

import json
import sys
import os
import green_gdk as gdk

def check_address_in_environment(environment, address, verbose=False):
    """Check all GAIDs in an environment for the given address."""
    
    # Suppress warnings if not verbose
    original_stderr = None
    if not verbose:
        original_stderr = sys.stderr
        sys.stderr = open(os.devnull, 'w')
    
    try:
        gdk.init({'datadir': '.', 'log_level': 'warn'})
    except:
        pass
    
    # Environment-specific mnemonics (from local gaid.py)
    mnemonics = {
        'dev': "vote ball voice juice visit license music off paddle hold suffer beach someone hover wheat boring protect broccoli issue opinion uniform media update arrange",
        'test': "hood novel finish couch rack pistol march army gun bring universe unknown hurry famous vote enact inspire whisper violin blur chief into engage cigar",
        'amp': "perfect grit monkey disorder cliff exhibit meat giant dream secret liberty walnut later caught snow wasp bulb bind feature couple vault flower credit bundle"
    }
    
    mnemonic = mnemonics.get(environment)
    if not mnemonic:
        return None
    
    # Create session
    session = gdk.Session({'name': 'testnet-liquid'})
    credentials = {'mnemonic': mnemonic}
    
    try:
        session.login_user({}, credentials).resolve()
    except:
        try:
            session.register_user({}, credentials).resolve()
            session.login_user({}, credentials).resolve()
        except:
            return None
    
    # Get all subaccounts
    subaccounts_result = session.get_subaccounts().resolve()
    
    # Check each 2of2_no_recovery subaccount
    for subaccount in subaccounts_result['subaccounts']:
        if subaccount['type'] != '2of2_no_recovery':
            continue
            
        gaid = subaccount['receiving_id']
        pointer = subaccount['pointer']
        
        if verbose:
            print(f"  Checking GAID: {gaid}", end=" ... ")
        
        # Check current receive address
        try:
            current_addr = session.get_receive_address({'subaccount': pointer}).resolve()
            if current_addr['address'] == address:
                if verbose:
                    print("FOUND! (current receive address)")
                else:
                    if original_stderr:
                        sys.stderr.close()
                        sys.stderr = original_stderr
                return gaid, environment, "current"
        except:
            pass
        
        # Check previous addresses
        try:
            prev_addrs = session.get_previous_addresses({
                'subaccount': pointer,
                'last_pointer': 100  # Check first 100 addresses
            }).resolve()
            
            if 'list' in prev_addrs:
                for i, addr_info in enumerate(prev_addrs['list']):
                    if addr_info.get('address') == address:
                        if verbose:
                            print(f"FOUND! (address index {i})")
                        else:
                            if original_stderr:
                                sys.stderr.close()
                                sys.stderr = original_stderr
                        return gaid, environment, f"index_{i}"
        except:
            pass
        
        if verbose:
            print("not found")
    
    if not verbose and original_stderr:
        sys.stderr.close()
        sys.stderr = original_stderr
    
    return None

def main():
    if len(sys.argv) < 2:
        print("Usage: python find_address_local.py <address> [-v|--verbose]")
        sys.exit(1)
    
    address = sys.argv[1]
    verbose = '-v' in sys.argv or '--verbose' in sys.argv
    
    print(f"Searching for address: {address}")
    if verbose:
        print()
    
    environments = ['dev', 'test', 'amp']
    found = False
    
    for env in environments:
        if verbose:
            print(f"Checking {env} environment:")
        
        result = check_address_in_environment(env, address, verbose)
        
        if result:
            gaid, environment, location = result
            found = True
            print(f"\n✓ Address found!")
            print(f"  Environment: {environment}")
            print(f"  GAID: {gaid}")
            print(f"  Location: {location}")
            
            # Now check balance for this GAID
            print(f"\nChecking balance for {gaid} in {environment} environment...")
            os.system(f"python3 balance.py {environment} {gaid}")
            break
        elif verbose:
            print(f"  Not found in {env} environment\n")
    
    if not found:
        print(f"\n✗ Address not found in any environment")

if __name__ == "__main__":
    main()