dequanto 0.0.1 → 0.0.7

package/dist/src/ns/utils/$ns.js

@@ -1,15 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$ns = void 0;
-const web3_utils_1 = require("web3-utils");
+const web3_1 = __importDefault(require("web3"));
 var $ns;
 (function ($ns) {
     function namehash(domain) {
         let labels = domain.toLowerCase().split('.');
         let node = '0x' + ''.padStart(64, '0');
         for (let i = labels.length - 1; i >= 0; i--) {
-            let labelSha = (0, web3_utils_1.keccak256)(labels[i]).substring(2);
-            node = (0, web3_utils_1.keccak256)(`${node}${labelSha}`);
+            let labelSha = web3_1.default.utils.keccak256(labels[i]).substring(2);
+            node = web3_1.default.utils.keccak256(`${node}${labelSha}`);
         }
         return node;
     }

package/dist/src/safe/$gnosis.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$gnosis = void 0;
+const safe_web3_lib_1 = __importDefault(require("@gnosis.pm/safe-web3-lib"));
+const _hex_1 = require("@dequanto/utils/$hex");
+var $gnosis;
+(function ($gnosis) {
+    async function getAdapter(owner, client) {
+        const web3 = await client.getWeb3();
+        if (owner.key) {
+            web3.eth.accounts.wallet.add(_hex_1.$hex.ensure(owner.key));
+        }
+        const ethAdapter = new safe_web3_lib_1.default({
+            web3: web3,
+            signerAddress: owner.address,
+        });
+        return ethAdapter;
+    }
+    $gnosis.getAdapter = getAdapter;
+})($gnosis = exports.$gnosis || (exports.$gnosis = {}));

package/dist/src/safe/GnosisSafeFactory.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GnosisSafeFactory = void 0;
+const safe_core_sdk_1 = require("@gnosis.pm/safe-core-sdk");
+const _gnosis_1 = require("./$gnosis");
+const GnosisSafeHandler_1 = require("./GnosisSafeHandler");
+class GnosisSafeFactory {
+    static async create(owner, client, config) {
+        const ethAdapter = await _gnosis_1.$gnosis.getAdapter(owner, client);
+        const safeFactory = await safe_core_sdk_1.SafeFactory.create({
+            ethAdapter,
+            contractNetworks: config.contracts
+        });
+        const safeAccountConfig = {
+            owners: config.owners,
+            threshold: config.threshold ?? config.owners.length,
+        };
+        const safeSdk = await safeFactory.deploySafe({ safeAccountConfig });
+        const safe = new GnosisSafeHandler_1.GnosisSafeHandler({
+            safeAddress: safeSdk.getAddress(),
+            owner: owner,
+            client: client,
+        });
+        return safe;
+    }
+}
+exports.GnosisSafeFactory = GnosisSafeFactory;

package/dist/src/safe/GnosisSafeHandler.js

@@ -0,0 +1,361 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GnosisSafeHandler = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const memd_1 = __importDefault(require("memd"));
+const alot_1 = __importDefault(require("alot"));
+const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
+const safe_core_sdk_1 = __importDefault(require("@gnosis.pm/safe-core-sdk"));
+const _address_1 = require("@dequanto/utils/$address");
+const _signRaw_1 = require("@dequanto/utils/$signRaw");
+const ContractWriter_1 = require("@dequanto/contracts/ContractWriter");
+const _gnosis_1 = require("./$gnosis");
+const GnosisServiceTransport_1 = require("./transport/GnosisServiceTransport");
+const _logger_1 = require("@dequanto/utils/$logger");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const ethers_1 = require("ethers");
+const _contract_1 = require("@dequanto/utils/$contract");
+const _promise_1 = require("@dequanto/utils/$promise");
+class GnosisSafeHandler {
+    constructor(config) {
+        this.safeAddress = config.safeAddress;
+        this.owner = config.owner;
+        this.client = config.client ?? a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client);
+        this.transport = config.transport ?? new GnosisServiceTransport_1.GnosisServiceTransport(this.client, this.owner);
+    }
+    async getTx(safeTxHash) {
+        return this.transport.getTx(safeTxHash);
+    }
+    async getTxConfirmations(safeTxHash) {
+        return this.transport.getTxConfirmations(safeTxHash);
+    }
+    async confirmTx(safeTxHash, owner) {
+        let acc = owner ?? this.owner;
+        let signature = _signRaw_1.$signRaw.signEC(safeTxHash, acc.key);
+        return this.transport.confirmTx(safeTxHash, {
+            owner: acc.address,
+            signature: signature.signature
+        });
+    }
+    async submitTransaction(safeTxHash, options) {
+        let tx = await this.transport.getTx(safeTxHash);
+        let writer = a_di_1.default.resolve(ContractWriter_1.ContractWriter, this.safeAddress, this.client);
+        let confirmations = tx.confirmations;
+        if (options?.threshold != null) {
+            let needCount = options.threshold;
+            if (confirmations.length < needCount) {
+                throw new Error(`Require ${needCount} confirmations, but got ${confirmations.length} for the tx ${safeTxHash}`);
+            }
+            if (confirmations.length > needCount) {
+                // get confirmations count as required
+                confirmations = confirmations.slice(0, needCount);
+            }
+        }
+        let signaturesArr = (0, alot_1.default)(confirmations)
+            .sortBy(x => x.owner)
+            .map(x => x.signature)
+            .toArray();
+        let signatures = '0x' + signaturesArr.map(x => x.substring(2)).join('');
+        let args = [
+            tx.to,
+            tx.value,
+            tx.data ?? '0x',
+            tx.operation,
+            tx.safeTxGas,
+            tx.baseGas,
+            tx.gasPrice,
+            tx.gasToken,
+            tx.refundReceiver,
+            signatures,
+        ];
+        let txWriter = await writer.writeAsync(this.owner, SafeAbi.execTransaction, args);
+        return txWriter;
+    }
+    async execute(writer) {
+        let value = BigInt(writer.builder.data.value?.toString() ?? 0);
+        let { safeTxHash, threshold, safeTxData } = await this.createTransaction(writer, value);
+        if (writer.options.txOutput != null) {
+            await writer.saveTxAndExit({ safeTxHash, safeTxData });
+            return;
+        }
+        await _promise_1.$promise.waitForObject(async () => {
+            let confirmations = await this.getTxConfirmations(safeTxHash);
+            if (confirmations.count >= threshold) {
+                return [null, {}];
+            }
+            const addr = confirmations.results?.map(x => x.owner)?.join(', ');
+            _logger_1.$logger.log(`Require ${threshold} confirmations. Got ${confirmations.count} (${addr}). Waiting`);
+            return [null, null];
+        }, {
+            intervalMs: 3000
+        });
+        let tx = await this.submitTransaction(safeTxHash, { threshold });
+        return tx;
+    }
+    async createTxHash(builder, value) {
+        let txData = builder.getTxData(this.client);
+        let safeTxEstimation = {
+            to: _address_1.$address.toChecksum(txData.to),
+            value: _bigint_1.$bigint.toHex(value ?? BigInt(txData.value?.toString() ?? 0n)),
+            data: txData.data ?? null,
+            operation: 0,
+        };
+        let safeInfo = await this.transport.getSafeInfo(this.safeAddress);
+        // let estimated = await this.transport.estimateSafeTransaction(this.safeAddress, safeTxEstimation);
+        let safeTxData = {
+            ...safeTxEstimation,
+            safeTxGas: 0,
+            baseGas: 0,
+            gasToken: _address_1.$address.ZERO,
+            refundReceiver: _address_1.$address.ZERO,
+            nonce: safeInfo.nonce,
+            gasPrice: 0,
+        };
+        let safeTxHash = await this.getTransactionHash({
+            ...safeTxData,
+        });
+        return {
+            safeInfo,
+            safeTxData,
+            safeTxHash,
+        };
+    }
+    async createTxSignature(safeTxHash) {
+        return {
+            signature: {
+                signer: _address_1.$address.toChecksum(this.owner.address),
+                data: _signRaw_1.$signRaw.signEC(safeTxHash, this.owner.key).signature
+            }
+        };
+    }
+    async createTransaction(writer, value) {
+        let builder = writer.builder;
+        let { safeTxHash, safeTxData, safeInfo, } = await this.createTxHash(builder, value);
+        let { signature, } = await this.createTxSignature(safeTxHash);
+        let signatures = new Map();
+        signatures.set(this.owner.address.toLowerCase(), signature);
+        // https://docs.gnosis-safe.io/tutorials/tutorial_tx_service_initiate_sign
+        let txProps = {
+            safeAddress: _address_1.$address.toChecksum(this.safeAddress),
+            senderAddress: _address_1.$address.toChecksum(this.owner.address),
+            safeTransaction: {
+                data: safeTxData,
+                signatures: signatures,
+            },
+            safeTxHash,
+        };
+        await this.transport.proposeTransaction(txProps);
+        writer.emit('safeTxProposed', txProps);
+        return {
+            threshold: Number(safeInfo.threshold),
+            safeTxData,
+            safeTxHash
+        };
+    }
+    async getSafeSdk() {
+        let adapter = await this.getAdapter();
+        const safeSdk = await safe_core_sdk_1.default.create({
+            ethAdapter: adapter,
+            safeAddress: this.safeAddress
+        });
+        return safeSdk;
+    }
+    async getAdapter() {
+        return _gnosis_1.$gnosis.getAdapter(this.owner, this.client);
+    }
+    getTransactionHash(params) {
+        let args = [
+            params.to,
+            params.value ? _bigint_1.$bigint.toHex(params.value) : 0,
+            params.data ?? '0x',
+            params.operation,
+            params.safeTxGas,
+            params.baseGas ?? 0,
+            params.gasPrice ?? 0,
+            params.gasToken ?? _address_1.$address.ZERO,
+            params.refundReceiver ?? _address_1.$address.ZERO,
+            params.nonce,
+        ];
+        return this.client.readContract({
+            address: this.safeAddress,
+            method: 'getTransactionHash',
+            arguments: args,
+            abi: [
+                SafeAbi.getTransactionHash
+            ]
+        });
+    }
+    static parseSafeTx(buffer, value) {
+        const inter = new ethers_1.utils.Interface([SafeAbi.execTransaction]);
+        const decodedInput = inter.parseTransaction({
+            data: buffer,
+            value: value,
+        });
+        return {
+            name: decodedInput.name,
+            args: _contract_1.$contract.normalizeArgs(Array.from(decodedInput.args))
+        };
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], GnosisSafeHandler.prototype, "getSafeSdk", null);
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], GnosisSafeHandler.prototype, "getAdapter", null);
+exports.GnosisSafeHandler = GnosisSafeHandler;
+// https://etherscan.io/address/0x34cfac646f301356faa8b21e94227e3583fe3f5f#code
+const SafeAbi = {
+    nonce: {
+        "constant": true,
+        "inputs": [],
+        "name": "nonce",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    execTransaction: {
+        "type": "function",
+        "stateMutability": "payable",
+        "outputs": [
+            {
+                "type": "bool",
+                "name": "",
+                "internalType": "bool"
+            }
+        ],
+        "name": "execTransaction",
+        "inputs": [
+            {
+                "type": "address",
+                "name": "to",
+                "internalType": "address"
+            },
+            {
+                "type": "uint256",
+                "name": "value",
+                "internalType": "uint256"
+            },
+            {
+                "type": "bytes",
+                "name": "data",
+                "internalType": "bytes"
+            },
+            {
+                "type": "uint8",
+                "name": "operation",
+                "internalType": "enum Enum.Operation"
+            },
+            {
+                "type": "uint256",
+                "name": "safeTxGas",
+                "internalType": "uint256"
+            },
+            {
+                "type": "uint256",
+                "name": "baseGas",
+                "internalType": "uint256"
+            },
+            {
+                "type": "uint256",
+                "name": "gasPrice",
+                "internalType": "uint256"
+            },
+            {
+                "type": "address",
+                "name": "gasToken",
+                "internalType": "address"
+            },
+            {
+                "type": "address",
+                "name": "refundReceiver",
+                "internalType": "address payable"
+            },
+            {
+                "type": "bytes",
+                "name": "signatures",
+                "internalType": "bytes"
+            }
+        ]
+    },
+    getTransactionHash: {
+        "type": "function",
+        "stateMutability": "view",
+        "outputs": [
+            {
+                "type": "bytes32",
+                "name": "",
+                "internalType": "bytes32"
+            }
+        ],
+        "name": "getTransactionHash",
+        "inputs": [
+            {
+                "type": "address",
+                "name": "to",
+                "internalType": "address"
+            },
+            {
+                "type": "uint256",
+                "name": "value",
+                "internalType": "uint256"
+            },
+            {
+                "type": "bytes",
+                "name": "data",
+                "internalType": "bytes"
+            },
+            {
+                "type": "uint8",
+                "name": "operation",
+                "internalType": "enum Enum.Operation"
+            },
+            {
+                "type": "uint256",
+                "name": "safeTxGas",
+                "internalType": "uint256"
+            },
+            {
+                "type": "uint256",
+                "name": "baseGas",
+                "internalType": "uint256"
+            },
+            {
+                "type": "uint256",
+                "name": "gasPrice",
+                "internalType": "uint256"
+            },
+            {
+                "type": "address",
+                "name": "gasToken",
+                "internalType": "address"
+            },
+            {
+                "type": "address",
+                "name": "refundReceiver",
+                "internalType": "address"
+            },
+            {
+                "type": "uint256",
+                "name": "_nonce",
+                "internalType": "uint256"
+            }
+        ]
+    }
+};

package/dist/src/safe/transport/FileServiceTransport.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileServiceTransport = void 0;
+const GnosisSafe_1 = require("@dequanto-contracts/gnosis/GnosisSafe");
+const atma_io_1 = require("atma-io");
+const _address_1 = require("@dequanto/utils/$address");
+class FileServiceTransport {
+    constructor(client, owner, path) {
+        this.client = client;
+        this.owner = owner;
+        this.path = path;
+    }
+    async getTx(safeTxHash) {
+        let current = await this.get();
+        let tx = current.find(x => x.safeTxHash === safeTxHash);
+        if (tx == null) {
+            throw new Error(`Safe Tx not found in ${this.path}`);
+        }
+        return tx;
+    }
+    async getTxConfirmations(safeTxHash) {
+        let tx = await this.getTx(safeTxHash);
+        let confirmations = tx.confirmations ?? [];
+        return {
+            count: confirmations.length,
+            results: confirmations
+        };
+    }
+    async confirmTx(safeTxHash, sig) {
+        let arr = await this.get();
+        let tx = arr.find(x => x.safeTxHash === safeTxHash);
+        if (tx == null) {
+            throw new Error(`Safe Tx not found in ${this.path}`);
+        }
+        let confirmations = tx.confirmations;
+        if (confirmations == null) {
+            confirmations = tx.confirmations = [];
+        }
+        let currentSig = confirmations.find(x => _address_1.$address.eq(x.owner, sig.owner));
+        if (currentSig) {
+            // already signed
+            return currentSig;
+        }
+        let innerSig = {
+            owner: sig.owner,
+            signature: sig.signature
+        };
+        confirmations.push(innerSig);
+        await this.save(arr);
+        return sig;
+    }
+    async getSafeInfo(safeAddress) {
+        let contract = new GnosisSafe_1.GnosisSafe(safeAddress, this.client);
+        let [nonce, threshold] = await Promise.all([
+            contract.nonce(),
+            contract.getThreshold(),
+        ]);
+        return { nonce, threshold };
+    }
+    async estimateSafeTransaction(safeAddress, safeTxEstimation) {
+        return {
+            safeTxGas: '0x0'
+        };
+    }
+    async proposeTransaction(args) {
+        let arr = await this.get();
+        let current = arr.find(x => x.safeTxHash === args.safeTxHash);
+        if (current) {
+            //already created
+            return;
+        }
+        arr.push({
+            ...args.safeTransaction.data,
+            safe: args.safeAddress,
+            safeTxHash: args.safeTxHash,
+            confirmations: [],
+        });
+        await this.save(arr);
+    }
+    async get() {
+        try {
+            return await atma_io_1.File.readAsync(this.path, { cached: false });
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    async save(arr) {
+        await atma_io_1.File.writeAsync(this.path, arr);
+    }
+}
+exports.FileServiceTransport = FileServiceTransport;

package/dist/src/safe/transport/GnosisServiceTransport.js

@@ -0,0 +1,78 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GnosisServiceTransport = void 0;
+const safe_service_client_1 = __importDefault(require("@gnosis.pm/safe-service-client"));
+const memd_1 = __importDefault(require("memd"));
+const _gnosis_1 = require("../$gnosis");
+class GnosisServiceTransport {
+    constructor(client, owner) {
+        this.client = client;
+        this.owner = owner;
+    }
+    async getTx(safeTxHash) {
+        let service = await this.getService();
+        let resp = await service.getTransaction(safeTxHash);
+        return resp;
+    }
+    async getTxConfirmations(safeTxHash) {
+        let service = await this.getService();
+        let resp = await service.getTransactionConfirmations(safeTxHash);
+        return resp;
+    }
+    async confirmTx(safeTxHash, sig) {
+        let service = await this.getService();
+        let resp = await service.confirmTransaction(safeTxHash, sig.signature);
+        return resp;
+    }
+    async getSafeInfo(safeAddress) {
+        let service = await this.getService();
+        let safeInfo = await service.getSafeInfo(safeAddress);
+        return safeInfo;
+    }
+    async estimateSafeTransaction(safeAddress, safeTxEstimation) {
+        let service = await this.getService();
+        let safeInfo = await service.estimateSafeTransaction(safeAddress, safeTxEstimation);
+        return safeInfo;
+    }
+    async proposeTransaction(args) {
+        let service = await this.getService();
+        await service.proposeTransaction(args);
+    }
+    async getService() {
+        let adapter = await this.getAdapter();
+        const safeService = new safe_service_client_1.default({
+            txServiceUrl: this.getServiceApiEndpoint(Number(this.client.chainId)),
+            ethAdapter: adapter
+        });
+        return safeService;
+    }
+    getServiceApiEndpoint(chainId) {
+        let network = '';
+        if (chainId === 100) {
+            network = `xdai.`;
+        }
+        if (chainId === 137) {
+            network = `polygon.`;
+        }
+        return `https://safe-transaction.${network}gnosis.io/`;
+    }
+    async getAdapter() {
+        return _gnosis_1.$gnosis.getAdapter(this.owner, this.client);
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], GnosisServiceTransport.prototype, "getService", null);
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], GnosisServiceTransport.prototype, "getAdapter", null);
+exports.GnosisServiceTransport = GnosisServiceTransport;

package/dist/src/safe/transport/ISafeServiceTransport.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/safe/transport/InMemoryServiceTransport.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryServiceTransport = void 0;
+const GnosisSafe_1 = require("@dequanto-contracts/gnosis/GnosisSafe");
+class InMemoryServiceTransport {
+    constructor(client, owner) {
+        this.client = client;
+        this.owner = owner;
+        this.txs = {};
+    }
+    async getTx(safeTxHash) {
+        return this.txs[safeTxHash];
+    }
+    async getTxConfirmations(safeTxHash) {
+        let tx = this.txs[safeTxHash];
+        let confirmations = tx.confirmations ?? [];
+        return {
+            count: confirmations.length,
+            results: confirmations
+        };
+    }
+    async confirmTx(safeTxHash, sig) {
+        let tx = this.txs[safeTxHash];
+        let confirmations = tx.confirmations;
+        if (confirmations == null) {
+            confirmations = tx.confirmations = [];
+        }
+        let innerSig = {
+            owner: sig.owner,
+            signature: sig.signature
+        };
+        confirmations.push(innerSig);
+        return sig;
+    }
+    async getSafeInfo(safeAddress) {
+        let contract = new GnosisSafe_1.GnosisSafe(safeAddress, this.client);
+        let [nonce, threshold] = await Promise.all([
+            contract.nonce(),
+            contract.getThreshold(),
+        ]);
+        return { nonce, threshold };
+    }
+    async estimateSafeTransaction(safeAddress, safeTxEstimation) {
+        return {
+            safeTxGas: '0x0'
+        };
+    }
+    async proposeTransaction(args) {
+        this.txs[args.safeTxHash] = {
+            safe: args.safeAddress,
+            confirmations: [],
+            ...args.safeTransaction.data
+        };
+    }
+}
+exports.InMemoryServiceTransport = InMemoryServiceTransport;