N3 Beta dAPI documentation

Neo2 dAPI N3 Beta dAPI
menu

Example

If you need to call the N3 dAPI monitoring method, you need to initialize NEOLine after initializing NEOLineN3, please refer to the example on the right.


let neoline;
let neolineN3;

function initDapi() {
    const initCommonDapi = new Promise((resolve, reject) => {
        window.addEventListener('NEOLine.NEO.EVENT.READY', () => {
            neoline = new NEOLine.Init();
            if (neoline) {
                resolve(neoline);
            } else {
                reject('common dAPI method failed to load.');
            }
        });
    });
    const initN3Dapi = new Promise((resolve, reject) => {
        window.addEventListener('NEOLine.N3.EVENT.READY', () => {
            neolineN3 = new NEOLineN3.Init();
            if (neolineN3) {
                resolve(neolineN3);
            } else {
                reject('N3 dAPI method failed to load.');
            }
        });
    });
    initCommonDapi.then(() => {
        console.log('The common dAPI method is loaded.');
        return initN3Dapi;
    }).then(() => {
        console.log('The N3 dAPI method is loaded.');
    }).catch((err) => {
        console.log(err);
    })
};

initDapi();
        

getProvider

Returns information about the dAPI provider, including who this provider is, the version of their dAPI, and the NEP that the interface is compatible with.

Input Arguments

None

Success Response
ParameterDescription
name: stringThe name of the wallet provider
website: stringThe website of the wallet provider
version: stringThe version of the dAPI that the the wallet supports
compatibility: string[]A list of all applicable NEPs which the wallet provider supports
extra: objectThis object can contain any attributes specific to the dapi provider, such as an app theme
Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neolineN3.getProvider()
.then(provider => {
    const {
        name,
        website,
        version,
        compatibility,
        extra
    } = provider;

    console.log('Provider name: ' + name);
    console.log('Provider website: ' + website);
    console.log('Provider dAPI version: ' + version);
    console.log('Provider dAPI compatibility: ' + JSON.stringify(compatibility));
    console.log('Extra provider specific atributes: ' + JSON.stringify(compatibility));
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'CONNECTION_DENIED':
            console.log('The user rejected the request to connect with your dApp.');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    name: 'Awesome Wallet',
    website: 'https://www.neoline.io/',
    version: '1.0.0',
    compatibility: [],
    extra: {}
}

getBalance

Return balance of a specific asset for the given account.

If the asset is omited from a request to MainNet, all asset and token balances will be returned.

Input Arguments
ParameterDescription
params: iBalanceRequest[]A list of Balance Request Objects, specifying which addresses, and which assets to query

BalanceRequest

ParameterDescription
address: stringAddress to check balance(s)
contracts: string[]contracts is a list of contract hash
Success Response
ParameterDescription
[address: string]: iBalanceResponse[]This key is the actual address of the query eg. "NdJqYNVK99srFABQDLPdrpz2By1RX1sLvr"

BalanceResponse

ParameterDescription
contract: stringcontract of the given hash
symbol: stringSymbol of the given contract
amount: stringDouble Value of the balance represented as a String
/* Example */
neolineN3.getBalance()
.then((results) => {
    Object.keys(results).forEach(address => {
        const balances = results[address];
        balances.forEach(balance => {
            const { contract, symbol, amount } = balance

            console.log('Address: ' + address);
            console.log('contract: ' + contract);
            console.log('Asset symbol: ' + symbol);
            console.log('Amount: ' + amount);
        });
    });
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'CONNECTION_DENIED':
            console.log('The user rejected the request to connect with your dApp');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

// output
[
    {
        "symbol": "NEO",
        "amount": "5000000",
        "contract": "0xef4073a0f2b305a38ec4050e4d3d28bc40ea63f5"
    },
    {
        "symbol": "GAS",
        "amount": "10063.4476161",
        "contract": "0xd2a4cff31913016155e38e474a2c06d08be276cf"
    }
]
    

getStorage

Reads the raw value in smart contract storage.

Input Arguments
ParameterDescription
scriptHash: stringScript hash of the smart contract to invoke a read on
key: stringKey of the storage value to retrieve from the contract
Success Response
ParameterDescription
result: stringThe raw value that's stored in the contract
Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neolineN3.getStorage({
    scriptHash: '006b26dd0d2aa076b11082847a094772450f05af',
    key: 'token0',
})
.then(result => {
    const value = result;
    console.log('Storage value: ' + value.result);
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'CONNECTION_REFUSED':
            console.log('Connection dApp not connected. Please call the "connect" function.');
            break;
        case 'RPC_ERROR':
            console.log('There was an error when broadcasting this transaction to the network.');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    result: 'wYCMqLCTIUiax57E8Zd/O9xN3l8='
}
    

invokeRead

Execute a contract invocation in read-only mode.

Input Arguments
ParameterDescription
scriptHash: stringScript hash of the smart contract to invoke a read on
operation: stringOperation on the smart contract to call
args: iArgument[]Any input arguments for the operation
signers: iSigners[]Sender and the effective scope of signature
Success Response

The wallet will return the direct response from the RPC node.

ParameterDescription
script: stringThe script which was run
state: stringStatus of the executeion
gas_consumed: stringEstimated amount of GAS to be used to execute the invocation. (Up to 10 free per transaction)
stack: iArgument[]An array of response arguments

Argument

ParameterDescription
type: 'String' | 'Boolean' | 'Hash160' | 'Hash256' | 'Integer' | 'ByteArray' | 'Array' | 'Address'The type of the argument with you are using. The type is an array, please see the example for the value.
value: stringString representation of the argument which you are using

Signer

ParameterDescription
account: stringscriptHash of the address
scopes: numberiEffective range of the signature
allowedContracts?: ArraySigns array of the allowed contract scripts
allowedGroups?: ArraySigns public keys of the allowed contract groups

Scopes

FieldDescription
0The signature is used for transactions only, and is disabled in contracts
1The signature is only effective to the contract script called by Entry
16The signature is only effective to the specified contract script
32The signature is effective to contracts in the group.
128The signature is globally effective. It is the default value of Neo Legacy and is backward compatible.
Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neolineN3.invokeRead({
    scriptHash: 'd2a4cff31913016155e38e474a2c06d08be276cf',
    operation: 'transfer',
    args: [
        {
            "type": "Hash160",
            "value": "0xebae4ab3f21765e5f604dfdd590fdf142cfb89fa"
        },
        {
            "type": "Hash160",
            "value": "0xebae4ab3f21765e5f604dfdd590fdf142cfb89fa"
        },
        {
            "type": "Integer",
            "value": "10000"
        },
        {
            "type": "String",
            "value": ""
        }
    ],
    signers: [
        {
            account: "2cab903ff032ac693f8514581665be534beac39f",
            scopes: 1
        }
    ],
})
.then(result => {
  console.log('Read invocation result: ' + JSON.stringify(result));
})
.catch((error) => {
  const {type, description, data} = error;
  switch(type) {
    case 'NO_PROVIDER':
        console.log('No provider available.');
        break;
    case 'CONNECTION_REFUSED':
        console.log('Connection dApp not connected. Please call the "connect" function.');
        break;
    case 'RPC_ERROR':
        console.log('There was an error when broadcasting this transaction to the network.');
        break;
    default:
        // Not an expected error object.  Just write the error to the console.
        console.error(error);
        break;
  }
});

/* Example Response */
{
    script: "DAABECcMFPqJ+ywU3w9Z3d8E9uVlF/KzSq7rDBT6ifssFN8PWd3fBPblZRfys0qu6xTAHwwIdHJhbnNmZXIMFM924ovQBixKR47jVWEBExnzz6TSQWJ9W1I=",
    state:"HALT",
    stack:[
        {
            type:"Boolean",
            value:false
        }
    ]
}
/* Example, Type is array */
args: [
        {
            type: "Array",
            value: [
              {
                type: "String",
                value: "0x576f726c64"
              }, {
                type: "String",
                value: "0x576f726c64"
              }
            ]
        }
    ]
    

invokeReadMulti

Execute a contract invocation in read-only mode.

Input Arguments
ParameterDescription
scriptHash: stringScript hash of the smart contract to invoke a read on
operation: stringOperation on the smart contract to call
invokeReadArgs: iArgument[]Any input arguments for the operation
Success Response

The wallet will return the direct response from the RPC node.

ParameterDescription
script: stringThe script which was run
state: stringStatus of the executeion
gas_consumed: stringEstimated amount of GAS to be used to execute the invocation. (Up to 10 free per transaction)
stack: iArgument[]An array of response arguments

Argument

ParameterDescription
type: 'String' | 'Boolean' | 'Hash160' | 'Hash256' | 'Integer' | 'ByteArray' | 'Array' | 'Address'The type of the argument with you are using
value: stringString representation of the argument which you are using
Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neolineN3.invokeReadMulti({
    invokeReadArgs: [
        {
            scriptHash: "d2a4cff31913016155e38e474a2c06d08be276cf",
            operation: "balanceOf",
            args: [
                {
                    type: "Address",
                    value: "NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq",
                }
            ]
        },
        {
            scriptHash: "d2a4cff31913016155e38e474a2c06d08be276cf",
            operation: "balanceOf",
            args: [
                {
                    type: "Address",
                    value: "NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq",
                }
            ]
        }
    ],
    signers: [
        {
            account: "2cab903ff032ac693f8514581665be534beac39f",
            scopes: 1
        }
    ]
}).then(result => {
    console.log('Read invocation result: ' + JSON.stringify(result));
})
.catch((error) => {
  const {type, description, data} = error;
  switch(type) {
    case 'NO_PROVIDER':
        console.log('No provider available.');
        break;
    case 'CONNECTION_REFUSED':
        console.log('Connection dApp not connected. Please call the "connect" function.');
        break;
    case 'RPC_ERROR':
        console.log('There was an error when broadcasting this transaction to the network.');
        break;
    default:
        // Not an expected error object.  Just write the error to the console.
        console.error(error);
        break;
  }
});

/* Example Response */
[
    {
        "script": "DBRHsV1d1v6Pnc51X7CYvP4eBbMIAxHAHwwJYmFsYW5jZU9mDBTPduKL0AYsSkeO41VhARMZ88+k0kFifVtS",
        "state": "HALT",
        "stack": [
            {
                "type": "Integer",
                "value": "5293314113"
            }
        ]
    },
    {
        "script": "DBRHsV1d1v6Pnc51X7CYvP4eBbMIAxHAHwwJYmFsYW5jZU9mDBTPduKL0AYsSkeO41VhARMZ88+k0kFifVtS",
        "state": "HALT",
        "stack": [
            {
                "type": "Integer",
                "value": "5293314113"
            }
        ]
    }
]
    

verifyMessage

Returns whether the provided signature data matches the provided message and was signed by the account of the provided public key.

Input Arguments
ParameterDescription
message: stringSalt prefix + original message
data: stringSigned message
publicKey: stringPublic key of account that signed message
Success Response
ParameterDescription
result: booleanWhether the provided signature matches the provided message and public key
Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neolineN3.verifyMessage({
  message: '42e038cec78bed9f1e503c4b23254b23Hello world',
  data: 'be506bf7e6851960bfe45968bf5dbbf79a9dc5dc63ee5b88629acfb288c435649c2766e977d4bc76253d8590bb3ca3d9b70efd71d6f7eebdf060dfa58c6601fd',
  publicKey: '03ba9524bd7479414be713c3a4f6f3ef35f90bb4b08f0f552211bf734c24415230'
})
.then(result => {
  console.log('Signature data matches provided message and public key: ' + JSON.stringify(result));
})
.catch((error) => {
  const {type, description, data} = error;
  switch(type) {
    case 'NO_PROVIDER':
        console.log('No provider available.');
        break;
    case 'CONNECTION_DENIED':
        console.log('The user rejected the request to connect with your dApp');
        break;
    default:
        // Not an expected error object.  Just write the error to the console.
        console.error(error);
        break;
  }
});

/* Example Response */
{
  result: true
}
    

getBlock

Get information about a specific block.

Input Arguments
ParameterDescription
blockHeight: numberThe height of the block you would like to get information about
Success Response

The wallet will return the direct response from the RPC node.

Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neolineN3.getBlock({
    blockHeight: 190,
})
.then(result => {
    console.log('Block information: ' + JSON.stringify(result));
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'RPC_ERROR':
            console.log('There was an error when broadcasting this transaction to the network.');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    "hash": "0x70635ef3ab897294bcde97255ea1197f99d7d6c587f720430b78743d25f8b313",
    "size": 689,
    "version": 0,
    "previousblockhash": "0xb2462644577fdc9302abfe3517d07cbb9e7d51354872257901ba3ab1c2f4ead6",
    "merkleroot": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "time": 1616899442433,
    "index": 190,
    "primary": 6,
    "nextconsensus": "NNjNWMEgRw9bnvg7RkjSB9FZfzXUXfqovh",
    "witnesses": [
        {
            "invocation": "DEAl4+T5RivIUYtCcMDCw/W2G3VvNRWRD8iWv447hmeuUo1XxyqHvC9wFYWWu1ar2Qr6sO36mHlJI6W1lmTol7sSDEDZmjj1k/TGr2f4Ii3IUZyxzroJ6/6pBBZhgafUYFPX1zMJBXYPqpGP7Ppqw8n/jUOgYq7u0XAzzbCco7qT4/1mDECVyDVhe2EwxXpvp9bUGgVH9SOoXub7fsN7zB+7kiEXpSNU0Fp7kn4uIsLE8PlDfEyKktFAMPBEzw1+WJZr/MgmDEB0RS82LHuKwwHmQ24QuRfk6YuFs3bLXFdtvL0BrlwpYrtOEDr6hitybvJ6X2NBiRf5+O88MO/ph3KJwIc7deN4DEDOdD1Ks34NSPHqd/7tNt/kqjIokEkRfxSCoXoBdbuSwQBQr5G6q/a9MpE9WQ+td0+XCsOKPi82QzxXo/TLJnoJ",
            "verification": "FQwhAwCbdUDhDyVi5f2PrJ6uwlFmpYsm5BI0j/WoaSe/rCKiDCECPpsy6om5TQZuZJsST9UOOW7pE2no4qauGxHBcNAiJW0MIQNAjc1BY5b2R4OsWH6h4Vk8V9n+qIDIpqGSDpKiWUd4BgwhAqeDS+mzLimB0VfLW706y0LP0R6lw7ECJNekTpjFkQ8bDCECuixw9ZlvNXpDGYcFhZ+uLP6hPhFyligAdys9WIqdSr0MIQPOExCxK5ItwD/pBcxnN+YrOEwO+j8VZouFPQPAFoJb8AwhAuhZNE7zW7H/65wlUytAKMW4d9uGGtsIYcng7dPIxnyLF0F7zmyl"
        }
    ],
    "tx": [],
    "confirmations": 207480,
    "nextblockhash": "0xb95e56772d16a02f54c9f9cf071bdb60c92d4b6dc0f0eddd7c8388d5649f112b"
}
    

getTransaction

Get information about a specific transaction.

Input Arguments
ParameterDescription
txid: stringThe id of the transaction you would like to get information about
Success Response

The wallet will return the direct response from the RPC node.

Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neolineN3.getTransaction({
    txid: '0xe5a5fdacad0ba4e8d34d2fa0638357adb0f05e7fc902ec150739616320870f50'
})
.then(result => {
    console.log('Transaction details: ' + JSON.stringify(result));
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'RPC_ERROR':
            console.log('There was an error when broadcasting this transaction to the network.');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    "hash": "0xc156988547570d1c852d9a56324b2e09d89077ff0aee2070d0b470332ae1e083",
    "size": 244,
    "sys_fee": "0.0997775",
    "net_fee": "0.0124379",
    "block_index": 103879,
    "block_time": 1618238381713,
    "version": 0,
    "transfers": [
        {
            "hash": "0xc156988547570d1c852d9a56324b2e09d89077ff0aee2070d0b470332ae1e083",
            "src": "tx",
            "contract": "0xd2a4cff31913016155e38e474a2c06d08be276cf",
            "from": "",
            "to": "NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq",
            "amount": "0.00004914"
        },
        {
            "hash": "0xc156988547570d1c852d9a56324b2e09d89077ff0aee2070d0b470332ae1e083",
            "src": "tx",
            "contract": "0xef4073a0f2b305a38ec4050e4d3d28bc40ea63f5",
            "from": "NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq",
            "to": "NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq",
            "amount": "1"
        }
    ]
}
  

getApplicationLog

Get the application log for a given transaction.

Input Arguments
ParameterDescription
txid: stringThe id of the transaction you would like to get the application logs for
Success Response

The wallet will return the direct response from the RPC node.

Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neolineN3.getApplicationLog({
    txid: '0xe5a5fdacad0ba4e8d34d2fa0638357adb0f05e7fc902ec150739616320870f50',
})
.then(result => {
    console.log('Application log of transaction execution: ' + JSON.stringify(result));
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'RPC_ERROR':
            console.log('There was an error when broadcasting this transaction to the network.');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    "blockhash": "0xa8184d1fb08199ca8926f992b6253962c4a8047f7d4cfc5ac420e346fa761b03",
    "executions": [
        {
            "trigger": "OnPersist",
            "vmstate": "HALT",
            "gasconsumed": "0",
            "stack": [],
            "notifications": []
        },
        {
            "trigger": "PostPersist",
            "vmstate": "HALT",
            "gasconsumed": "0",
            "stack": [],
            "notifications": [
                {
                    "contract": "0xd2a4cff31913016155e38e474a2c06d08be276cf",
                    "eventname": "Transfer",
                    "state": {
                        "type": "Array",
                        "value": [
                            {
                                "type": "Any"
                            },
                            {
                                "type": "ByteString",
                                "value": "iQwOXsDt//2me0sNlRpUdBcVOg4="
                            },
                            {
                                "type": "Integer",
                                "value": "50000000"
                            }
                        ]
                    }
                }
            ]
        }
    ]
}
      

pickAddress

Get the application log for a given transaction.

Input Arguments

None

Error Response
ParameterDescription
label: stringThe type of error which has occured
address: stringA description of the error which has occured
/* Example */
neolineN3.pickAddress()
.then(result => {
    const { label, address } = result;
    console.log('label:' + label);
    console.log('address' + address);
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'CANCELED':
            console.log('The user cancels, or refuses the dapps request');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    label: 'N3-Name',
    address: 'NfuwpaQ1A2xaeVbxWe8FRtaRgaMa8yF3YM'
}
      

AddressToScriptHash

Converts an address to scripthash.

Input Arguments
ParameterDescription
address: stringThe is N3 address.
Success Response
ParameterDescription
scriptHash: stringSctiptHash is the script hash of the N3 account.
/* Example */
neolineN3.AddressToScriptHash({ address: 'NQUN2zkzwpypEi6kvGYexy8cQKN2ycyJjF' })
.then(result => {
    const { scriptHash } = result;
    console.log('scriptHash' + scriptHash);
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'MALFORMED_INPUT':
            console.log('Please check your input');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    scriptHash: 'f0a33d62f32528c25e68951286f238ad24e30032'
}
      

ScriptHashToAddress

Converts a scripthash to address.

Input Arguments
ParameterDescription
scriptHash: stringSctiptHash is the script hash of the N3 account.
Success Response
ParameterDescription
address: stringThe is N3 address.
/* Example */
neolineN3.ScriptHashToAddress({ scriptHash: 'f0a33d62f32528c25e68951286f238ad24e30032' })
.then(result => {
    const { address } = result;
    console.log('address' + address);
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'MALFORMED_INPUT':
            console.log('Please check your input');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    address: 'NQUN2zkzwpypEi6kvGYexy8cQKN2ycyJjF'
}
      

send

Invoke a transfer of a specified amount of a given asset from the connected account to another account.

Input Arguments
ParameterDescription
fromAddress: stringAddress of the connected account to send the assets from
toAddress: stringAddress of the receiver of the assets to be sent
asset: stringAsset script hash to be sent. Accepts asset symbol only for "MainNet"
amount: stringThe parsed amount of the asset to be sent
fee?: stringThe parsed amount of network fee (in GAS) to include with transaction
broadcastOverride?: booleanIn the case that the dApp would like to be responsible for broadcasting the signed transaction rather than the wallet provider
Success Response

In the case where the "broadcastOverride" input argument is not set, or set to false.

ParameterDescription
txid: stringThe transaction ID of the send invocation
nodeURL: stringThe node which the transaction was broadcast to. Returned if transaction is broadcast by wallet provider

In the case where the "broadcastOverride" input argument is set to True.

ParameterDescription
txid: stringThe transaction ID of the send invocation
signedTx: stringThe serialized signed transaction. Only returned if the broadcastOverride input argument was set to True
Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neolineN3.send({
    fromAddress: 'NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq',
    toAddress: 'NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq',
    asset: 'GAS',
    amount: '1',
    fee: '0.0001',
    broadcastOverride: false
})
.then(result => {
    console.log('Send transaction success!');
    console.log('Transaction ID: ' + result.txid);
    console.log('RPC node URL: ' + result.nodeURL);
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'RPC_ERROR':
            console.log('There was an error when broadcasting this transaction to the network.');
            break;
        case 'MALFORMED_INPUT':
            console.log('The receiver address provided is not valid.');
            break;
        case 'CANCELED':
            console.log('The user has canceled this transaction.');
            break;
        case 'INSUFFICIENT_FUNDS':
            console.log('The user has insufficient funds to execute this transaction.');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    txid: '0xd6e4edeb66a75b79bec526d14664017eef9ccee5650c32facb1a4d4fe3640808',
    nodeURL: 'https://neo3-testnet.neoline.vip'
};
      

invoke

Invoke allows for the generic execution of smart contracts on behalf of the user. It is reccommended to have a general understanding of the NEO blockchain, and to be able successfully use all other commands listed previously in this document before attempting a generic contract execution.

Input Arguments
ParameterDescription
scriptHash: stringScript hash of the smart contract to invoke
operation: stringOperation on the smart contract to call
args: iArgument[]Any input arguments for the operation
fee?: stringThe parsed amount of network fee (in GAS) to include with transaction
broadcastOverride?: booleanIn the case that the dApp would like to be responsible for broadcasting the signed transaction rather than the wallet provider
signers: iSigners[]Sender and the effective scope of signature

Argument

ParameterDescription
type: 'String' | 'Boolean' | 'Hash160' | 'Hash256' | 'Integer' | 'ByteArray' | 'Array' | 'Address'The type of the argument with you are using
value: anyString representation of the argument which you are using

In the case where the "broadcastOverride" input argument is set to True.

ParameterDescription
signedTx: stringThe serialized signed transaction. Only returned if the broadcastOverride input argument was set to True
Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neolineN3.invoke({
    scriptHash: 'ef4073a0f2b305a38ec4050e4d3d28bc40ea63f5',
    operation: 'transfer',
    args: [
        {
            type: "Address",
            value: "NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq",
        },
        {
            type: "Address",
            value: "NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq",
        },
        {
            type: "Integer",
            value: "1",
        },
        {
            type: "Any",
            value: null,
        }
    ],
    fee: '0.0001',
    broadcastOverride: false,
    signers: [
        {
            account: "2cab903ff032ac693f8514581665be534beac39f",
            scopes: 1
        }
    ]
})
.then(result => {
    console.log('Invoke transaction success!');
    console.log('Transaction ID: ' + result.txid);
    console.log('RPC node URL: ' + result.nodeURL);
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'RPC_ERROR':
            console.log('There was an error when broadcasting this transaction to the network.');
            break;
        case 'CANCELED':
            console.log('The user has canceled this transaction.');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    txid: '0xd6e4edeb66a75b79bec526d14664017eef9ccee5650c32facb1a4d4fe3640808',
    nodeURL: 'https://neo3-testnet.neoline.vip'
};
      

invokeMultiple

Invoke Multiple functions the same as Invoke, but accepts inputs to execute multiple invokes in the same transaction.

Input Arguments
ParameterDescription
fee?: stringIf a fee is specified then the wallet SHOULD NOT override it, if a fee is not specified the wallet SHOULD allow the user to attach an optional fee
invokeArgs?: iInvokeArguments[]Array of contract invoke inputs
broadcastOverride?: booleanIf this flag is set to True, the wallet provider will return the signed transaction rather than broadcasting to a node.
signers: iSigners[]Sender and the effective scope of signature

InvokeArguments

ParameterDescription
scriptHash: stringThe script hash of the contract that you wish to invoke
operation: stringThe operation on the smart contract that you wish to call. This can be fetched from the contract ABI
args: iArgument[]A list of arguments necessary to perform on the operation you wish to call

Argument

ParameterDescription
type: 'String' | 'Boolean' | 'Hash160' | 'Hash256' | 'Integer' | 'ByteArray' | 'Array' | 'Address'The type of the argument with you are using
value: anyString representation of the argument which you are using
Success Response

In the case where the "broadcastOverride" input argument is not set, or set to false.

ParameterDescription
txid: stringThe transaction ID of the invocation
nodeURL: stringThe node which the transaction was broadcast to. Returned if transaction is broadcast by wallet provider

In the case where the "broadcastOverride" input argument is set to True.

ParameterDescription
signedTx: stringThe serialized signed transaction. Only returned if the broadcastOverride input argument was set to True
Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neolineN3.invokeMultiple({
    invokeArgs: [
        {
            scriptHash: "ef4073a0f2b305a38ec4050e4d3d28bc40ea63f5",
            operation: "transfer",
            args: [
                {
                    type: "Address",
                    value: "NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq",
                },
                {
                    type: "Address",
                    value: "NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq",
                },
                {
                    type: "Integer",
                    value: "1",
                },
                {
                    type: "Any",
                    value: null
                }
            ]
        },
        {
            scriptHash: "ef4073a0f2b305a38ec4050e4d3d28bc40ea63f5",
            operation: "transfer",
            args: [
                {
                    type: "Address",
                    value: "NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq",
                },
                {
                    type: "Address",
                    value: "NPsCvedTnzGcwSYuoxjh7Sec5Zem2vgVmX",
                },
                {
                    type: "Integer",
                    value: "1",
                },
                {
                    type: "Any",
                    value: null
                }
            ]
        }
    ],
    fee: '0.001',
    broadcastOverride: true,
    signers: [
        {
            account: "2cab903ff032ac693f8514581665be534beac39f",
            scopes: 1
        }
    ]
})
.then(({txid, nodeURL}: InvokeOutput) => {
    console.log('Invoke transaction success!');
    console.log('Transaction ID: ' + txid);
    console.log('RPC node URL: ' + nodeURL);
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'RPC_ERROR':
            console.log('There was an error when broadcasting this transaction to the network.');
            break;
        case 'CANCELED':
            console.log('The user has canceled this transaction.');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    txid: '0xd6e4edeb66a75b79bec526d14664017eef9ccee5650c32facb1a4d4fe3640808',
    nodeURL: 'https://neo3-testnet.neoline.vip'
};
      

signMessage

Signs a provided messaged with an account selected by user. A randomized salt prefix is added to the input string before it is signed, and it is encased in a non-executable transaction before signed. This ensures compatibility with Ledger devices.

Input Arguments
ParameterDescription
message: stringThe message to sign
Success Response
ParameterDescription
publicKey: stringPublic key of account that signed message
data: stringOriginal message signed
salt: stringSalt added to original message as prefix, before signing
message: stringSigned message
Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neolineN3.signMessage({
  message: 'Hello world'
})
.then(signedMessage => {
  const {
    publicKey,
    message,
    salt,
    data
  } = signedMessage;

  console.log('Public key used to sign:', publicKey);
  console.log('Original message:', message);
  console.log('Salt added to message:', salt);
  console.log('Signed data:', data);
})
.catch((error) => {
  const {type, description, data} = error;
  switch(type) {
    case 'UNKNOWN_ERROR':
        console.log(description);
        break;
    default:
        // Not an expected error object.  Just write the error to the console.
        console.error(error);
        break;
  }
});

/* Example Response */
{
  publicKey: '"03ba9524bd7479414be713c3a4f6f3ef35f90bb4b08f0f552211bf734c24415230"',
  data: '"be506bf7e6851960bfe45968bf5dbbf79a9dc5dc63ee5b88629acfb288c435649c2766e977d4bc76253d8590bb3ca3d9b70efd71d6f7eebdf060dfa58c6601fd"',
  salt: '',
  message: 'Hello world'
}
      

Example

Please instantiate it before calling the common methods and common events of Neo2 and N3. See the example for details.


window.addEventListener('NEOLine.NEO.EVENT.READY', () => {
    const neoline = new NEOLine.Init();
});
        

getNetworks

Returns the networks the wallet provider has available to connect to, along with the default network the wallet is currently set to.

Input Arguments

None

Success Response
ParameterDescription
networks: string[]Array of network names the wallet provider has available for the dapp developer to connect to
chainId:inumberChainId the wallet is currently set to
defaultNetwork: stringNetwork the wallet is currently set to
Chain IDs Type

These are the IDs of the Neo chain supported by NeoLine.

chainIdDescription
1ChainId 1 is the Neo2 MainNet
2ChainId 2 is the Neo2 TestNet
3ChainId 3 is the N3 MainNet
4ChainId 4 is the N3 TestNet (Currently only N3 TestNet)
Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neoline.getNetworks()
.then(result => {
    const {
        chainId,
        networks,
        defaultNetwork
    } = result;

    console.log('chainId: ' + chainId);
    // eg. 4

    console.log('Networks: ' + networks);
    // eg. ["MainNet", "TestNet", "N3TestNet"]

    console.log('Default network: ' + defaultNetwork);
    // eg. "N3TestNet"
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'CONNECTION_DENIED':
            console.log('The user rejected the request to connect with your dApp');
            break;
        case 'CHAIN_NOT_MATCH':
            console.log('The currently opened chain does not match the type of the call chain, please switch the chain.');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    chainId: 4,
    networks: ["MainNet", "TestNet", "N3TestNet"],
    defaultNetwork: "N3TestNet"
}
        

getAccount

Return the Account that is currently connected to the dApp.

Input Arguments

None

Success Response
ParameterDescription
address: stringAddress of the connected account
label?: stringA label the users has set to identify their wallet
Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neoline.getAccount()
.then(account => {
    const {
        address,
        label
    } = account;

    console.log('Provider address: ' + address);
    console.log('Provider account label (Optional): ' + label);
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'CONNECTION_DENIED':
            console.log('The user rejected the request to connect with your dApp');
            break;
        case 'CHAIN_NOT_MATCH':
            console.log('The currently opened chain does not match the type of the call chain, please switch the chain.');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    address: 'NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq',
    label: 'NEOLine'
}

getPublicKey

Return the public key of the Account that is currently connected to the dApp.

Input Arguments

None

Success Response
ParameterDescription
address: stringAddress of the connected account
publicKey: stringPublic key of the connected account
Error Response
ParameterDescription
type: stringThe type of error which has occured
description: stringA description of the error which has occured
data: stringAny raw data associated with the error
/* Example */
neoline.getPublicKey()
.then(publicKeyData => {
    const {
        address,
        publicKey
    } = publicKeyData;

    console.log('Account address: ' + address);
    console.log('Account public key: ' + publicKey);
})
.catch((error) => {
    const {type, description, data} = error;
    switch(type) {
        case 'NO_PROVIDER':
            console.log('No provider available.');
            break;
        case 'CONNECTION_DENIED':
            console.log('The user rejected the request to connect with your dApp');
            break;
        default:
            // Not an expected error object.  Just write the error to the console.
            console.error(error);
            break;
    }
});

/* Example Response */
{
    address: 'NaUjKgf5vMuFt7Ffgfffcpc41uH3adx1jq',
    publicKey: '6PYKGV4numxfoswwCedXzhb1oNCC8W4tEdfFPdtWtFa8WidpzYfeJkd2To'
}
    

READY

On a READY event, the callback will fire with a single argument with information about the wallet provider. At any time a READY event listener is added, it will immidiately be called if the provider is already in a ready state. This provides a single flow for dapp developers since this listener should start any and all interactions with the dapi protocol.

ParameterDescription
name: stringThe name of the wallet provider
website: stringThe website of the wallet provider
version: stringThe version of the dAPI that the the wallet supports
compatibility: string[]A list of all applicable NEPs which the wallet provider supports
extra: objectProvider specific attributes
/* Example */
window.addEventListener('NEOLine.NEO.EVENT.READY', () => {
    console.log('dAPI common method loading is complete.');
});
                

ACCOUNT_CHANGED

On a ACCOUNT_CHANGED event, the callback will fire with a single argument of the new account. This occurs when an account is already connected to the dapp, and the user has changed the connected account from the dapi provider side.

ParameterDescription
address: stringAddress of the connected account
label: stringA label the users has set to identify their wallet

/* Example */
neoline.addEventListener(neoline.EVENT.ACCOUNT_CHANGED, (result) => {
    console.log('account changed:', result);
});
/* Another */
window.addEventListener('NEOLine.NEO.EVENT.ACCOUNT_CHANGED', (result) => {
    console.log('account changed:', result.detail);
});
                

CONNECTED

On a CONNECTED event, the user has approved the connection of the dapp with one of their accounts. This will fire the first time any of one of the following methods are called from the dapp: getAccount, invoke, send.

ParameterDescription
address: stringAddress of the new account
label: stringA label the users has set to identify their wallet

/* Example */
neoline.addEventListener(neoline.EVENT.CONNECTED, (result) => {
    console.log('connected account:', result);
});
/* Another */
window.addEventListener('NEOLine.NEO.EVENT.CONNECTED', (result) => {
    console.log('connected account:', result.detail);
});
                

DISCONNECTED

On a DISCONNECTED event, the account connected to the dapp via the dapi provider has been disconnected (logged out).


/* Example */
neoline.addEventListener(neoline.EVENT.DISCONNECTED, () => {
    console.log('dAPI public method loading is complete.');
});
/* Another */
window.addEventListener('NEOLine.NEO.EVENT.DISCONNECTED', () => {
    console.log('dAPI public method loading is complete.');
});
                

NETWORK_CHANGED

On a NETWORK_CHANGED event, the user has changed the network their provider wallet is connected to. The event will return the updated network details.

ParameterDescription
networks: string[]A list of all networks which this wallet provider allows access to
chainId:inumberchainId the wallet is currently set to
defaultNetwork: stringNetwork the wallet is currently set to

/* Example */
neoline.addEventListener(neoline.EVENT.NETWORK_CHANGED, (result) => {
    console.log('network:', result);
});
/* Another */
window.addEventListener('NEOLine.NEO.EVENT.NETWORK_CHANGED', (result) => {
    console.log('network:', result.detail);
});
                

BLOCK_HEIGHT_CHANGED

On a BLOCK_HEIGHT_CHANGED event, the block has advanced to the next.

ParameterDescription
chainId: numberChainId is the type of wallet selection network
blockHeight: numberHeight of the new block
blockTime: numberTimestamp of the new block
blockHash: stringHash of the new block
tx: string[]List of transaction ids executed in the new block

/* Example */
neoline.addEventListener(neoline.EVENT.BLOCK_HEIGHT_CHANGED, (result) => {
    console.log('block height:', result);
});
/* Another */
window.addEventListener('NEOLine.NEO.EVENT.BLOCK_HEIGHT_CHANGED', (result) => {
    console.log('block height:', result.detail);
});
                

TRANSACTION_CONFIRMED

On a TRANSACTION_CONFIRMED event, a previously broadcast transaction via the dapi has been confirmed by the blockchain.

ParameterDescription
chainId: numberChainId is the type of wallet selection network
txid: stringTransaction id which was confirmed on chain
blockHeight: numberHeight of the new block
blockTime: numberTimestamp of the new block

/* Example */
neoline.addEventListener(neoline.EVENT.TRANSACTION_CONFIRMED, (result) => {
    console.log('Transaction confirmation detail:', result);
});
/* Another */
window.addEventListener('NEOLine.NEO.EVENT.TRANSACTION_CONFIRMED', (result) => {
    console.log('Transaction confirmation detail:', result.detail);
});
                

addEventListener

Method is used to add a callback method to be triggered on a specified event.

/* Example */
const fn = (data) => {
    console.log(`Connected Account: ${data.address}`);
}
neoline.addEventListener(neoline.EVENT.ACCOUNT_CHANGED, fn);
/* Another */
const fn = (data) => {
    console.log(`Connected Account: ${data.detail.address}`);
}
window.addEventListener('NEOLine.NEO.EVENT.ACCOUNT_CHANGED', fn) ;
                

removeEventListener

Method is to remove existing callback event listeners.

/* Example */
neoline.removeEventListener(neoline.EVENT.ACCOUNT_CHANGED, fn);
/* Another */
window.removeEventListener('NEOLine.NEO.EVENT.ACCOUNT_CHANGED', fn);

                

Errors

The NEO dAPI will provide these basic errors. It is up to the wallet provider to provide additional information if they choose:

Error TypeMeaning
NO_PROVIDERThrown when there is no interface capable of interacting with NEO blockchain
CONNECTION_DENIEDThrown when API provider refuses to execute a transaction (e.g. trying to execute a transaction on an unavialable network)
RPC_ERRORThrown when a command relying on RPC connection to a network node fails
MALFORMED_INPUTThrown when an input such as the address is not a valid NEO address
CANCELEDThrown when a user cancels, or refuses the dapps request
INSUFFICIENT_FUNDSThrown when the action does not have a sufficient balance
CHAIN_NOT_MATCHThe currently opened chain does not match the type of the call chain, please switch the chain
SCRIPT_ERRORScript creation error, please check whether the parameters are correct
FAILThe request failed