钱包开发#

1
const bip39 = require('bip39');
2
const crypto = require('crypto');
3

4
// 1. 生成助记词
5
function generateMnemonic(strength = 128) {
6
    return bip39.generateMnemonic(strength);
7
}
8

9
// 2. 验证助记词
10
function validateMnemonic(mnemonic) {
11
    return bip39.validateMnemonic(mnemonic);
12
}
13

14
// 3. 助记词转种子
15
function mnemonicToSeed(mnemonic, passphrase = '') {
16
    return bip39.mnemonicToSeedSync(mnemonic, passphrase);
17
}
18

19
// 4. 种子转助记词
20
function seedToMnemonic(seed) {
21
    return bip39.entropyToMnemonic(seed);
22
}

1
const HDKey = require('hdkey');
2
const secp256k1 = require('secp256k1');
3

4
// 1. 创建HD钱包
5
function createHDWallet(mnemonic, passphrase = '') {
6
    const seed = bip39.mnemonicToSeedSync(mnemonic, passphrase);
7
    const hdkey = HDKey.fromMasterSeed(seed);
8
    return hdkey;
9
}
10

11
// 2. 派生密钥
12
function deriveKey(hdkey, path) {
13
    const derived = hdkey.derive(path);
14
    return {
15
        privateKey: derived.privateKey,
16
        publicKey: derived.publicKey,
17
        address: deriveAddress(derived.publicKey)
18
    };
19
}
20

21
// 3. 派生地址
22
function deriveAddress(publicKey) {
23
    const hash = crypto.createHash('sha256').update(publicKey).digest();
24
    const address = '0x' + hash.slice(-20).toString('hex');
25
    return address;
26
}

1
m / purpose' / coin_type' / account' / change / address_index

1
// 1. 定义币种类型
2
const COIN_TYPES = {
3
    BITCOIN: 0,
4
    ETHEREUM: 60,
5
    LITECOIN: 2,
6
    DOGECOIN: 3
7
};
8

9
// 2. 生成路径
10
function generatePath(coinType, account = 0, change = 0, addressIndex = 0) {
11
    return `m/44'/${coinType}'/${account}'/${change}/${addressIndex}`;
12
}
13

14
// 3. 派生地址
15
function deriveAddressFromPath(hdkey, coinType, account, change, addressIndex) {
16
    const path = generatePath(coinType, account, change, addressIndex);
17
    const derived = hdkey.derive(path);
18
    return deriveAddress(derived.publicKey);
19
}

1
contract MultiSigWallet {
2
    address[] public owners;
3
    uint256 public required;
4
    mapping(bytes32 => bool) public approved;
5

6
    event Deposit(address indexed sender, uint256 amount);
7
    event Submit(uint256 indexed txId);
8
    event Approve(address indexed owner, uint256 indexed txId);
9
    event Revoke(address indexed owner, uint256 indexed txId);
10
    event Execute(uint256 indexed txId);
11

12
    struct Transaction {
13
        address to;
14
        uint256 value;
15
        bytes data;
16
        bool executed;
17
    }
18

19
    Transaction[] public transactions;
20

21
    modifier onlyOwner() {
22
        require(isOwner[msg.sender], "Not owner");
23
        _;
24
    }
25

26
    modifier txExists(uint256 _txId) {
27
        require(_txId < transactions.length, "Tx does not exist");
28
        _;
29
    }
30

31
    modifier notExecuted(uint256 _txId) {
32
        require(!transactions[_txId].executed, "Tx already executed");
33
        _;
34
    }
35

36
    modifier notApproved(uint256 _txId) {
37
        require(!approved[keccak256(abi.encodePacked(msg.sender, _txId))], "Tx already approved");
38
        _;
39
    }
40

41
    constructor(address[] memory _owners, uint256 _required) {
42
        require(_owners.length > 0, "Owners required");
43
        require(_required > 0 && _required <= _owners.length, "Invalid required number of owners");
44

45
        for (uint256 i = 0; i < _owners.length; i++) {
46
            address owner = _owners[i];
47
            require(owner != address(0), "Invalid owner");
48
            require(!isOwner[owner], "Owner not unique");
49

50
            isOwner[owner] = true;
51
            owners.push(owner);
52
        }
53

54
        required = _required;
55
    }
56

57
    receive() external payable {
58
        emit Deposit(msg.sender, msg.value);
59
    }
60

61
    function submit(
62
        address _to,
63
        uint256 _value,
64
        bytes calldata _data
65
    ) external onlyOwner {
66
        transactions.push(Transaction({
67
            to: _to,
68
            value: _value,
69
            data: _data,
70
            executed: false
71
        }));
72

73
        emit Submit(transactions.length - 1);
74
    }
75

76
    function approve(uint256 _txId) external onlyOwner txExists(_txId) notExecuted(_txId) notApproved(_txId) {
77
        approved[keccak256(abi.encodePacked(msg.sender, _txId))] = true;
78
        emit Approve(msg.sender, _txId);
79
    }
80

81
    function revoke(uint256 _txId) external onlyOwner txExists(_txId) notExecuted(_txId) {
82
        require(approved[keccak256(abi.encodePacked(msg.sender, _txId))], "Tx not approved");
83
        approved[keccak256(abi.encodePacked(msg.sender, _txId))] = false;
84
        emit Revoke(msg.sender, _txId);
85
    }
86

87
    function execute(uint256 _txId) external txExists(_txId) notExecuted(_txId) {
88
        require(_getApprovalCount(_txId) >= required, "Approvals < required");
89

90
        Transaction storage transaction = transactions[_txId];
91
        transaction.executed = true;
92

93
        (bool success, ) = transaction.to.call{value: transaction.value}(transaction.data);
94
        require(success, "Tx failed");
95

96
        emit Execute(_txId);
97
    }
98

99
    function _getApprovalCount(uint256 _txId) private view returns (uint256 count) {
100
        for (uint256 i = 0; i < owners.length; i++) {
101
            if (approved[keccak256(abi.encodePacked(owners[i], _txId))]) {
102
                count += 1;
103
            }
104
        }
105
    }
106
}

1
class MultiSigWallet {
2
    constructor(contract, signers) {
3
        this.contract = contract;
4
        this.signers = signers;
5
    }
6

7
    // 1. 提交交易
8
    async submitTransaction(to, value, data) {
9
        const tx = await this.contract.submit(to, value, data);
10
        return tx;
11
    }
12

13
    // 2. 批准交易
14
    async approveTransaction(txId) {
15
        const tx = await this.contract.approve(txId);
16
        return tx;
17
    }
18

19
    // 3. 撤销批准
20
    async revokeApproval(txId) {
21
        const tx = await this.contract.revoke(txId);
22
        return tx;
23
    }
24

25
    // 4. 执行交易
26
    async executeTransaction(txId) {
27
        const tx = await this.contract.execute(txId);
28
        return tx;
29
    }
30

31
    // 5. 获取交易信息
32
    async getTransaction(txId) {
33
        const tx = await this.contract.transactions(txId);
34
        return tx;
35
    }
36

37
    // 6. 获取批准数量
38
    async getApprovalCount(txId) {
39
        const count = await this.contract.getApprovalCount(txId);
40
        return count;
41
    }
42
}

1
const crypto = require('crypto');
2

3
// 1. 生成随机数
4
function generateRandom() {
5
    return crypto.randomBytes(32);
6
}
7

8
// 2. 生成多项式
9
function generatePolynomial(degree, secret) {
10
    const coefficients = [secret];
11
    for (let i = 1; i <= degree; i++) {
12
        coefficients.push(generateRandom());
13
    }
14
    return coefficients;
15
}
16

17
// 3. 计算多项式值
18
function evaluatePolynomial(coefficients, x) {
19
    let result = 0n;
20
    for (let i = 0; i < coefficients.length; i++) {
21
        result += BigInt(coefficients[i]) * (BigInt(x) ** BigInt(i));
22
    }
23
    return result;
24
}
25

26
// 4. 生成密钥份额
27
function generateKeyShares(secret, threshold, totalShares) {
28
    const coefficients = generatePolynomial(threshold - 1, secret);
29
    const shares = [];
30

31
    for (let i = 1; i <= totalShares; i++) {
32
        const share = evaluatePolynomial(coefficients, i);
33
        shares.push({ index: i, value: share });
34
    }
35

36
    return shares;
37
}

1
// 1. 拉格朗日插值
2
function lagrangeInterpolation(shares, threshold) {
3
    let secret = 0n;
4

5
    for (let i = 0; i < threshold; i++) {
6
        let term = shares[i].value;
7

8
        for (let j = 0; j < threshold; j++) {
9
            if (i !== j) {
10
                const numerator = BigInt(0 - shares[j].index);
11
                const denominator = BigInt(shares[i].index - shares[j].index);
12
                term = (term * numerator) / denominator;
13
            }
14
        }
15

16
        secret += term;
17
    }
18

19
    return secret;
20
}
21

22
// 2. 生成签名
23
function generateSignature(message, privateKey) {
24
    const hash = crypto.createHash('sha256').update(message).digest();
25
    const signature = secp256k1.sign(hash, privateKey);
26
    return signature;
27
}
28

29
// 3. 验证签名
30
function verifySignature(message, signature, publicKey) {
31
    const hash = crypto.createHash('sha256').update(message).digest();
32
    return secp256k1.verify(hash, signature, publicKey);
33
}

1
const Transport = require('@ledgerhq/hw-transport-node-hid').default;
2
const AppEth = require('@ledgerhq/hw-app-eth').default;
3

4
// 1. 连接设备
5
async function connectDevice() {
6
    const transport = await Transport.create();
7
    const app = new AppEth(transport);
8
    return app;
9
}
10

11
// 2. 获取地址
12
async function getAddress(app, path) {
13
    const result = await app.getAddress(path);
14
    return result.address;
15
}
16

17
// 3. 签名交易
18
async function signTransaction(app, path, transaction) {
19
    const result = await app.signTransaction(path, transaction);
20
    return result;
21
}

1
// 1. 生成密钥对
2
async function generateKeyPair(app, path) {
3
    const result = await app.getAddress(path);
4
    return {
5
        address: result.address,
6
        publicKey: result.publicKey
7
    };
8
}
9

10
// 2. 签名消息
11
async function signMessage(app, path, message) {
12
    const result = await app.signPersonalMessage(path, message);
13
    return result;
14
}
15

16
// 3. 验证签名
17
function verifySignature(message, signature, publicKey) {
18
    const hash = crypto.createHash('sha256').update(message).digest();
19
    return secp256k1.verify(hash, signature, publicKey);
20
}

1
class MultiChainWallet {
2
    constructor() {
3
        this.chains = new Map();
4
        this.initializeChains();
5
    }
6

7
    // 1. 初始化链
8
    initializeChains() {
9
        this.chains.set('ethereum', new EthereumChain());
10
        this.chains.set('bitcoin', new BitcoinChain());
11
        this.chains.set('solana', new SolanaChain());
12
    }
13

14
    // 2. 获取地址
15
    async getAddress(chain, path) {
16
        const chainInstance = this.chains.get(chain);
17
        return await chainInstance.getAddress(path);
18
    }
19

20
    // 3. 发送交易
21
    async sendTransaction(chain, transaction) {
22
        const chainInstance = this.chains.get(chain);
23
        return await chainInstance.sendTransaction(transaction);
24
    }
25

26
    // 4. 查询余额
27
    async getBalance(chain, address) {
28
        const chainInstance = this.chains.get(chain);
29
        return await chainInstance.getBalance(address);
30
    }
31
}

1
class CrossChainBridge {
2
    constructor(sourceChain, targetChain) {
3
        this.sourceChain = sourceChain;
4
        this.targetChain = targetChain;
5
    }
6

7
    // 1. 锁定资产
8
    async lockAssets(amount, targetAddress) {
9
        const tx = await this.sourceChain.lockAssets(amount, targetAddress);
10
        return tx;
11
    }
12

13
    // 2. 解锁资产
14
    async unlockAssets(amount, sourceAddress, proof) {
15
        const tx = await this.targetChain.unlockAssets(amount, sourceAddress, proof);
16
        return tx;
17
    }
18

19
    // 3. 验证证明
20
    async verifyProof(proof) {
21
        return await this.targetChain.verifyProof(proof);
22
    }
23
}

1
// 1. 私钥加密存储
2
class SecureKeyStore {
3
    constructor(password) {
4
        this.password = password;
5
        this.encryptedKeys = new Map();
6
    }
7

8
    // 加密私钥
9
    encryptPrivateKey(privateKey) {
10
        const cipher = crypto.createCipher('aes-256-cbc', this.password);
11
        let encrypted = cipher.update(privateKey, 'utf8', 'hex');
12
        encrypted += cipher.final('hex');
13
        return encrypted;
14
    }
15

16
    // 解密私钥
17
    decryptPrivateKey(encryptedKey) {
18
        const decipher = crypto.createDecipher('aes-256-cbc', this.password);
19
        let decrypted = decipher.update(encryptedKey, 'hex', 'utf8');
20
        decrypted += decipher.final('utf8');
21
        return decrypted;
22
    }
23
}

1
// 1. 防重放攻击
2
class AntiReplayWallet {
3
    constructor() {
4
        this.usedNonces = new Set();
5
    }
6

7
    // 生成nonce
8
    generateNonce() {
9
        return Date.now() + Math.random();
10
    }
11

12
    // 验证nonce
13
    validateNonce(nonce) {
14
        if (this.usedNonces.has(nonce)) {
15
            throw new Error('Nonce already used');
16
        }
17
        this.usedNonces.add(nonce);
18
        return true;
19
    }
20
}

1
// 1. 多重验证
2
class MultiFactorWallet {
3
    constructor() {
4
        this.factors = [];
5
    }
6

7
    // 添加验证因子
8
    addFactor(factor) {
9
        this.factors.push(factor);
10
    }
11

12
    // 验证所有因子
13
    async verifyAllFactors() {
14
        const results = await Promise.all(
15
            this.factors.map(factor => factor.verify())
16
        );
17
        return results.every(result => result);
18
    }
19
}

1
// 1. 交易监控
2
class TransactionMonitor {
3
    constructor() {
4
        this.suspiciousPatterns = [];
5
    }
6

7
    // 监控交易
8
    monitorTransaction(transaction) {
9
        const risk = this.assessRisk(transaction);
10
        if (risk > 0.8) {
11
            this.alert(transaction);
12
        }
13
    }
14

15
    // 评估风险
16
    assessRisk(transaction) {
17
        let risk = 0;
18

19
        // 检查金额
20
        if (transaction.value > 1000000) {
21
            risk += 0.3;
22
        }
23

24
        // 检查地址
25
        if (this.isSuspiciousAddress(transaction.to)) {
26
            risk += 0.5;
27
        }
28

29
        return risk;
30
    }
31
}

1
/* 1. 响应式布局 */
2
.wallet-container {
3
    display: flex;
4
    flex-direction: column;
5
    min-height: 100vh;
6
}
7

8
@media (min-width: 768px) {
9
    .wallet-container {
10
        flex-direction: row;
11
    }
12
}
13

14
/* 2. 移动端优化 */
15
.mobile-wallet {
16
    padding: 16px;
17
    font-size: 16px;
18
}
19

20
.mobile-wallet input {
21
    width: 100%;
22
    padding: 12px;
23
    border: 1px solid #ddd;
24
    border-radius: 4px;
25
}

1
// 1. 加载状态
2
class LoadingManager {
3
    constructor() {
4
        this.loading = false;
5
    }
6

7
    async withLoading(asyncFunction) {
8
        this.loading = true;
9
        try {
10
            const result = await asyncFunction();
11
            return result;
12
        } finally {
13
            this.loading = false;
14
        }
15
    }
16
}
17

18
// 2. 错误处理
19
class ErrorHandler {
20
    constructor() {
21
        this.errors = [];
22
    }
23

24
    handleError(error) {
25
        this.errors.push(error);
26
        this.showError(error.message);
27
    }
28

29
    showError(message) {
30
        // 显示错误消息
31
        console.error(message);
32
    }
33
}

1
// 1. 缓存管理
2
class CacheManager {
3
    constructor() {
4
        this.cache = new Map();
5
        this.ttl = 5 * 60 * 1000; // 5分钟
6
    }
7

8
    // 设置缓存
9
    set(key, value) {
10
        this.cache.set(key, {
11
            value,
12
            timestamp: Date.now()
13
        });
14
    }
15

16
    // 获取缓存
17
    get(key) {
18
        const item = this.cache.get(key);
19
        if (!item) return null;
20

21
        if (Date.now() - item.timestamp > this.ttl) {
22
            this.cache.delete(key);
23
            return null;
24
        }
25

26
        return item.value;
27
    }
28
}

1
// 1. 异步队列
2
class AsyncQueue {
3
    constructor() {
4
        this.queue = [];
5
        this.processing = false;
6
    }
7

8
    // 添加任务
9
    add(task) {
10
        this.queue.push(task);
11
        this.process();
12
    }
13

14
    // 处理任务
15
    async process() {
16
        if (this.processing) return;
17

18
        this.processing = true;
19
        while (this.queue.length > 0) {
20
            const task = this.queue.shift();
21
            await task();
22
        }
23
        this.processing = false;
24
    }
25
}

1
describe('Wallet', () => {
2
    let wallet;
3

4
    beforeEach(() => {
5
        wallet = new Wallet();
6
    });
7

8
    it('should generate mnemonic', () => {
9
        const mnemonic = wallet.generateMnemonic();
10
        expect(mnemonic).toBeDefined();
11
        expect(mnemonic.split(' ').length).toBe(12);
12
    });
13

14
    it('should derive address from path', () => {
15
        const address = wallet.deriveAddress("m/44'/60'/0'/0/0");
16
        expect(address).toMatch(/^0x[a-fA-F0-9]{40}$/);
17
    });
18

19
    it('should sign transaction', async () => {
20
        const transaction = {
21
            to: '0x...',
22
            value: 1000,
23
            nonce: 0
24
        };
25

26
        const signature = await wallet.signTransaction(transaction);
27
        expect(signature).toBeDefined();
28
    });
29
});

1
describe('Security', () => {
2
    it('should prevent private key exposure', () => {
3
        const wallet = new Wallet();
4
        const privateKey = wallet.getPrivateKey();
5
        expect(privateKey).toBeUndefined();
6
    });
7

8
    it('should validate transaction before signing', async () => {
9
        const wallet = new Wallet();
10
        const invalidTransaction = {
11
            to: 'invalid-address',
12
            value: -1000
13
        };
14

15
        await expect(wallet.signTransaction(invalidTransaction))
16
            .rejects.toThrow('Invalid transaction');
17
    });
18
});

1
describe('MultiChain', () => {
2
    it('should support multiple chains', async () => {
3
        const wallet = new MultiChainWallet();
4

5
        const ethAddress = await wallet.getAddress('ethereum', "m/44'/60'/0'/0/0");
6
        const btcAddress = await wallet.getAddress('bitcoin', "m/44'/0'/0'/0/0");
7

8
        expect(ethAddress).toMatch(/^0x[a-fA-F0-9]{40}$/);
9
        expect(btcAddress).toMatch(/^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/);
10
    });
11
});

1
# Dockerfile
2
FROM node:16-alpine
3

4
WORKDIR /app
5
COPY package*.json ./
6
RUN npm ci --only=production
7

8
COPY . .
9
RUN npm run build
10

11
EXPOSE 3000
12
CMD ["npm", "start"]

1
// 1. 性能监控
2
class PerformanceMonitor {
3
    constructor() {
4
        this.metrics = new Map();
5
    }
6

7
    // 记录指标
8
    recordMetric(name, value) {
9
        if (!this.metrics.has(name)) {
10
            this.metrics.set(name, []);
11
        }
12
        this.metrics.get(name).push(value);
13
    }
14

15
    // 获取指标
16
    getMetric(name) {
17
        const values = this.metrics.get(name) || [];
18
        return {
19
            count: values.length,
20
            average: values.reduce((a, b) => a + b, 0) / values.length,
21
            max: Math.max(...values),
22
            min: Math.min(...values)
23
        };
24
    }
25
}

1
// 1. 日志管理
2
class Logger {
3
    constructor() {
4
        this.logs = [];
5
    }
6

7
    // 记录日志
8
    log(level, message, data = {}) {
9
        const logEntry = {
10
            timestamp: new Date().toISOString(),
11
            level,
12
            message,
13
            data
14
        };
15

16
        this.logs.push(logEntry);
17
        console.log(JSON.stringify(logEntry));
18
    }
19

20
    // 错误日志
21
    error(message, error) {
22
        this.log('error', message, { error: error.message, stack: error.stack });
23
    }
24

25
    // 警告日志
26
    warn(message, data) {
27
        this.log('warn', message, data);
28
    }
29

30
    // 信息日志
31
    info(message, data) {
32
        this.log('info', message, data);
33
    }
34
}