eoscostarica / eoscostarica.io Goto Github PK

<script>

let wombatScatterPatched = false;
(function () {
    if (wombatScatterPatched) {
        return;
    }
    function arrayToHex(array) {
        return array.reduce((acc, i) => acc + i.toString(16).padStart(2, '0'), '');
    }
    function hexToUint8Array(hexString) {
        const buf = new Uint8Array(hexString.length / 2);
        for (let i = 0; i < hexString.length; i += 2) {
            buf[i / 2] = parseInt(hexString.substr(i, 2), 16);
        }
        return buf;
    }
    function sendToContentScript(message) {
        const id = Math.random().toFixed(10);
        return new Promise((resolve, reject) => {
            document.addEventListener('wombat-comm-' + id, (evt) => {
                const response = evt.detail;
                if (response.error) {
                    reject(response);
                }
                else {
                    resolve(response);
                }
            }, { once: true });
            document.dispatchEvent(new CustomEvent('wombat-comm', {
                detail: {
                    id: id,
                    message: message,
                },
            }));
        });
    }
    function patchScatter(scatter) {
        scatter.identity = null;
        scatter.isExtension = true;
        scatter.isConnected = () => true;
        scatter.requiredVersion = '';
        scatter.getVersion = () => Promise.resolve('10.1.12');
        scatter.publicKey = '';
        scatter.network = {
            chainId: 'aca376f206b8fc25a6ed44dbdc66547c36c6c33e3a119ffbeaef943642f0e906',
            host: 'localhost',
            blockchain: 'eos',
            port: 80,
            protocol: 'http',
            httpEndpoint: 'http://localhost',
        };
        scatter.connect = (applicationName, requiredFields) => {
            if (requiredFields && requiredFields.network) {
                scatter.network = requiredFields.network;
            }
            return Promise.resolve(true);
        };
        scatter.getIdentity = async (args) => {
            const chainId = args ? args.accounts[0].chainId : scatter.network.chainId;
            scatter.identity = await sendToContentScript({
                type: 0,
                chainId: chainId,
            });
            return scatter.identity;
        };
        scatter.login = scatter.getIdentity;
        scatter.account = () => {
            if (!scatter.identity)
                return null;
            return scatter.identity.accounts[0];
        };
        scatter.getIdentityFromPermissions = () => {
            if (scatter.identity) {
                return Promise.resolve(scatter.identity);
            }
            else {
                return scatter.getIdentity();
            }
        };
        scatter.checkLogin = scatter.getIdentityFromPermissions;
        scatter.forgetIdentity = () => {
            scatter.identity = null;
            return Promise.resolve(true);
        };
        scatter.logout = scatter.forgetIdentity;
        scatter.getPublicKey = () => {
            if (scatter.identity) {
                return Promise.resolve(scatter.identity.publicKey);
            }
            else {
                return Promise.resolve();
            }
        };
        scatter.requireVersion = required => {
            scatter.requiredVersion = required;
        };
        scatter.useIdentity = id => {
            scatter.identity = id;
        };
        scatter.suggestNetwork = () => Promise.resolve(true);
        async function signProvider(signargs) {
            const serializedTx = signargs.buf.toString('hex', 32, signargs.buf.length - 32);
            const res = await sendToContentScript({
                type: 1,
                chainId: scatter.network.chainId,
                serializedTx,
                modifiable: true,
                origin: document.location.host,
            });
            if (res.modified) {
                if (signargs.transaction.actions.find((action) => action.account === 'eosio')) {
                    signargs.transaction.actions.unshift({
                        account: 'genialwombat',
                        action: 'noop',
                        data: {},
                        authorization: [
                            {
                                actor: 'wombatresmgr',
                                permission: 'cosign',
                            },
                        ],
                    });
                }
                else {
                    signargs.transaction.actions[0].authorization.unshift({
                        actor: 'wombatresmgr',
                        permission: 'active',
                    });
                }
            }
            return res.signatures;
        }
        scatter.signProvider = signProvider;
        scatter.hookProvider = (network, requiredFields, isVersionBeta3) => ({
            requiredFields: {},
            getAvailableKeys() {
                if (scatter.identity) {
                    const keys = [scatter.identity.publicKey];
                    if (scatter.identity.accounts.length > 1) {
                        keys.push(scatter.identity.accounts[1].publicKey);
                    }
                    return Promise.resolve(keys);
                }
                else {
                    return Promise.resolve([]);
                }
            },
            async sign(signargs) {
                let { serializedTransaction } = signargs;
                if (serializedTransaction instanceof Uint8Array) {
                    serializedTransaction = arrayToHex(serializedTransaction);
                }
                const res = await sendToContentScript({
                    type: 1,
                    chainId: signargs.chainId,
                    serializedTx: serializedTransaction,
                    modifiable: isVersionBeta3 || false,
                    origin: document.location.host,
                });
                if (isVersionBeta3) {
                    if (res.modified) {
                        return {
                            serializedTransaction: hexToUint8Array(res.signedTx),
                            signatures: res.signatures,
                        };
                    }
                    else {
                        return {
                            serializedTransaction: hexToUint8Array(serializedTransaction),
                            signatures: res.signatures,
                        };
                    }
                }
                else {
                    return res.signatures;
                }
            },
        });
        scatter.eosHook = scatter.hookProvider;
        scatter.eosMultiHook = (network, signers) => {
            const allSigners = [scatter.hookProvider(network)].concat(signers);
            return {
                async getAvailableKeys() {
                    return Promise.all(allSigners.map(signer => signer.getAvailableKeys()))
                        .then(allKeys => allKeys.flat());
                },
                async sign(signargs) {
                    const allSignatures = await Promise.all(allSigners.map(async (signer) => signer.sign({
                        abis: signargs.abis,
                        chainId: network.chainId,
                        requiredKeys: await signer.getAvailableKeys(),
                        serializedTransaction: signargs.serializedTransaction,
                    }).then(res => {
                        if (Array.isArray(res)) {
                            return res;
                        }
                        else {
                            return res.signatures;
                        }
                    })));
                    return {
                        signatures: allSignatures.flat(),
                        serializedTransaction: signargs.serializedTransaction,
                    };
                },
            };
        };
        scatter.eos = (network, Eos, eosOptions, protocol) => {
            if (eosOptions && eosOptions.rpc) {
                const signatureProvider = scatter.hookProvider(network, {}, eosOptions.beta3 || true);
                return new Eos(Object.assign(eosOptions, { signatureProvider }));
            }
            else {
                eosOptions = eosOptions || {};
                scatter.network = Object.assign(scatter.network, network);
                if (!network.protocol) {
                    network.protocol = protocol || 'http';
                }
                const httpEndpoint = network.protocol + '://' + network.host + ':' + network.port;
                const chainId = network.chainId;
                return Eos(Object.assign(eosOptions, {
                    httpEndpoint,
                    chainId,
                    signProvider,
                }));
            }
        };
        scatter.getArbitrarySignature = (publicKey, data) => {
            return sendToContentScript({
                type: 2,
                data,
                chainId: scatter.network.chainId,
                origin: document.location.host,
            });
        };
        scatter.authenticate = (nonce, data) => {
            return sendToContentScript({
                type: 3,
                nonce,
                data,
                chainId: scatter.network.chainId,
                origin: document.location.host,
            });
        };
    }
    if (window.ScatterJS) {
        patchScatter(window.ScatterJS.scatter);
    }
    else {
        let scatterJS = undefined;
        Object.defineProperty(window, 'ScatterJS', {
            get() {
                return scatterJS;
            },
            set(ScatterJS) {
                if (ScatterJS) {
                    patchScatter(ScatterJS.scatter);
                }
                scatterJS = ScatterJS;
            },
        });
    }
    const scatter = {};
    patchScatter(scatter);
    window.scatter = scatter;
 …</script>