> ## Documentation Index
> Fetch the complete documentation index at: https://docs.near.org/llms.txt
> Use this file to discover all available pages before exploring further.
# Transfers & Actions
> Learn how contracts can make transfers, call other contracts, and more
export const Github = ({url, start, end, fname, withSourceLink = true}) => {
const [code, setCode] = useState(null);
function toRaw(ref) {
const fullUrl = ref.slice(ref.indexOf('https'));
const [url] = fullUrl.split('#');
const [org, repo, , branch, ...pathSeg] = new URL(url).pathname.split('/').slice(1);
return `https://raw.githubusercontent.com/${org}/${repo}/${branch}/${pathSeg.join('/')}`;
}
async function fetchCode(url, fromLine, toLine) {
let res;
if (typeof window !== 'undefined') {
const validUntil = localStorage.getItem(`${url}-until`);
if (validUntil && Number(validUntil) > Date.now()) {
res = localStorage.getItem(url);
}
}
if (!res) {
try {
res = await (await fetch(url)).text();
if (typeof window !== 'undefined') {
localStorage.setItem(url, res);
localStorage.setItem(`${url}-until`, String(Date.now() + 60000));
}
} catch {
return 'Error fetching code, please try reloading';
}
}
let body = res.split('\n');
const from = fromLine ? Number(fromLine) - 1 : 0;
const to = toLine ? Number(toLine) : body.length;
body = body.slice(from, to);
const precedingSpace = body.reduce((prev, line) => {
if (line.length === 0) return prev;
const spaces = line.match(/^\s+/);
if (spaces) return Math.min(prev, spaces[0].length);
return 0;
}, Infinity);
return body.map(line => line.slice(precedingSpace === Infinity ? 0 : precedingSpace)).join('\n');
}
function buildSourceUrl(url, start, end) {
const base = url.split('#')[0];
if (start && end) return `${base}#L${start}-L${end}`;
if (start) return `${base}#L${start}`;
return base;
}
useEffect(() => {
const rawUrl = toRaw(url);
fetchCode(rawUrl, start, end).then(res => setCode(res));
}, [url, start, end]);
const sourceUrl = buildSourceUrl(url, start, end);
const startLine = start ? Number(start) : 1;
const fileName = fname ?? sourceUrl.split('/').pop();
return
{}
{start && end &&
Lines {start}–{end}
}
{}
{code === null ?
Loading...
:
{code.split('\n').map((line, i) =>
|
{startLine + i}
|
{line || ' '}
|
)}
}
{}
{withSourceLink &&
}
#### Creating `.testnet` / `.near` Accounts
Accounts can only create immediate sub-accounts of themselves.
If your contract wants to create a `.mainnet` or `.testnet` account, then it needs to [call](#function-call)
the `create_account` method of `near` or `testnet` root contracts.
```rust theme={"theme":{"light":"github-light","dark":"github-dark"}}
use near_sdk::{near, Promise, Gas, NearToken };
use serde_json::json;
#[near(contract_state)]
#[derive(Default)]
pub struct Contract { }
const CALL_GAS: Gas = Gas::from_gas(28_000_000_000_000);
const MIN_STORAGE: NearToken = NearToken::from_yoctonear(1_820_000_000_000_000_000_000); //0.00182Ⓝ
#[near]
impl Contract {
pub fn create_account(&mut self, account_id: String, public_key: String){
let args = json!({
"new_account_id": account_id,
"new_public_key": public_key,
}).to_string().into_bytes().to_vec();
// Use "near" to create mainnet accounts
Promise::new("testnet".parse().unwrap())
.function_call("create_account".to_string(), args, MIN_STORAGE, CALL_GAS);
}
}
```
```js theme={"theme":{"light":"github-light","dark":"github-dark"}}
import { NearBindgen, near, call, bytes, NearPromise } from 'near-sdk-js'
const MIN_STORAGE: bigint = BigInt("1820000000000000000000"); //0.00182Ⓝ
const CALL_GAS: bigint = BigInt("28000000000000");
@NearBindgen({})
class Contract {
@call({})
create_account({account_id, public_key}:{account_id: String, public_key: String}) {
const args = bytes(JSON.stringify({
"new_account_id": account_id,
"new_public_key": public_key
}))
NearPromise.new("testnet")
.functionCall("create_account", args, MIN_STORAGE, CALL_GAS);
}
}
```
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
from near_sdk_py import call, Contract
from near_sdk_py.promises import Promise
from near_sdk_py.constants import ONE_NEAR, ONE_TGAS
# Constants
MIN_STORAGE = int(1.82 * ONE_NEAR / 1000) # 0.00182Ⓝ
CALL_GAS = 28 * ONE_TGAS
class ExampleContract(Contract):
@call
def create_account(self, account_id, public_key):
"""Create a testnet account by calling the testnet contract"""
# Create the arguments for the create_account method
args = {
"new_account_id": account_id,
"new_public_key": public_key
}
# Call the testnet contract to create the account
return Promise.create_batch("testnet")\
.function_call(
"create_account",
args,
MIN_STORAGE,
CALL_GAS
)
```
***
## Deploy a Contract
When creating an account you can also batch the action of deploying a contract to it. Note that for this, you will need to pre-load the byte-code you want to deploy in your contract.
```rust theme={"theme":{"light":"github-light","dark":"github-dark"}}
use near_sdk::{near, env, Promise, NearToken};
#[near(contract_state)]
#[derive(Default)]
pub struct Contract { }
const MIN_STORAGE: NearToken = NearToken::from_millinear(1100); //1.1Ⓝ
const HELLO_CODE: &[u8] = include_bytes!("./hello.wasm");
#[near]
impl Contract {
pub fn create_hello(&self, prefix: String){
let account_id = prefix + "." + &env::current_account_id().to_string();
Promise::new(account_id.parse().unwrap())
.create_account()
.transfer(MIN_STORAGE)
.deploy_contract(HELLO_CODE.to_vec());
}
}
```
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
from near_sdk_py import call, Context, Contract
from near_sdk_py.promises import Promise
from near_sdk_py.constants import ONE_NEAR
class ExampleContract(Contract):
@call
def deploy_contract(self, prefix):
"""Create an account and deploy a contract to it"""
# This would require loading the contract bytes in Python
# Load contract bytes - for example purposes only
# In a real implementation, you'd need to read this from storage or include it
contract_bytes = b'...' # This should be actual WASM bytes
MIN_STORAGE = 1.1 * ONE_NEAR # 1.1Ⓝ
# Generate the new account ID
account_id = f"{prefix}.{self.current_account_id}"
# Create batch of actions
return Promise.create_batch(account_id)\
.create_account()\
.transfer(MIN_STORAGE)\
.deploy_contract(contract_bytes)
```
If an account with a contract deployed does **not** have any access keys, this is known as a locked contract. When the account is locked, it cannot sign transactions therefore, actions can **only** be performed from **within** the contract code.
***
## Add Keys
When you use actions to create a new account, the created account does not have any [access keys](../../protocol/accounts-contracts/access-keys), meaning that it **cannot sign transactions** (e.g. to update its contract, delete itself, transfer money).
There are two options for adding keys to the account:
1. `add_access_key`: adds a key that can only call specific methods on a specified contract.
2. `add_full_access_key`: adds a key that has full access to the account.
```rust theme={"theme":{"light":"github-light","dark":"github-dark"}}
use near_sdk::{near, env, Promise, NearToken, PublicKey};
#[near(serializers = [json, borsh])]
#[derive(Default)]
pub struct Contract { }
const MIN_STORAGE: NearToken = NearToken::from_millinear(1100); //1.1Ⓝ
const HELLO_CODE: &[u8] = include_bytes!("./hello.wasm");
#[near]
impl Contract {
pub fn create_hello(&self, prefix: String, public_key: PublicKey){
let account_id = prefix + "." + &env::current_account_id().to_string();
Promise::new(account_id.parse().unwrap())
.create_account()
.transfer(MIN_STORAGE)
.deploy_contract(HELLO_CODE.to_vec())
.add_full_access_key(public_key);
}
}
```
```js theme={"theme":{"light":"github-light","dark":"github-dark"}}
import { NearBindgen, near, call, NearPromise } from 'near-sdk-js'
import { PublicKey } from 'near-sdk-js/lib/types'
const MIN_STORAGE: bigint = BigInt("1000000000000000000000") // 0.001Ⓝ
@NearBindgen({})
class Contract {
@call({})
create_hello({prefix, public_key}:{prefix: String, public_key: PublicKey}) {
const account_id = `${prefix}.${near.currentAccountId()}`
NearPromise.new(account_id)
.createAccount()
.transfer(MIN_STORAGE)
.addFullAccessKey(public_key)
}
}
```
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
from near_sdk_py import call, Contract
from near_sdk_py.promises import Promise
from near_sdk_py.constants import ONE_NEAR
# Minimum amount needed for storage
MIN_STORAGE = ONE_NEAR // 1000 # 0.001Ⓝ
class ExampleContract(Contract):
@call
def create_with_key(self, prefix, public_key):
"""Create a subaccount with a full access key"""
# Generate the new account ID
account_id = f"{prefix}.{self.current_account_id}"
# Create the new account, transfer some NEAR, and add a key
return Promise.create_batch(account_id)\
.create_account()\
.transfer(MIN_STORAGE)\
.add_full_access_key(public_key)
```
Notice that what you actually add is a "public key". Whoever holds its private counterpart, i.e. the private-key, will be able to use the newly access key.
If an account with a contract deployed does **not** have any access keys, this is known as a locked contract. When the account is locked, it cannot sign transactions therefore, actions can **only** be performed from **within** the contract code.
***
## Delete Account
There are two scenarios in which you can use the `delete_account` action:
1. As the **last** action in a chain of batched actions.
2. To make your smart contract delete its own account.
```rust theme={"theme":{"light":"github-light","dark":"github-dark"}}
use near_sdk::{near, env, Promise, NearToken, AccountId};
#[near(contract_state)]
#[derive(Default)]
pub struct Contract { }
const MIN_STORAGE: NearToken = NearToken::from_millinear(1); //0.001Ⓝ
#[near]
impl Contract {
pub fn create_delete(&self, prefix: String, beneficiary: AccountId){
let account_id = prefix + "." + &env::current_account_id().to_string();
Promise::new(account_id.parse().unwrap())
.create_account()
.transfer(MIN_STORAGE)
.delete_account(beneficiary);
}
pub fn self_delete(beneficiary: AccountId){
Promise::new(env::current_account_id())
.delete_account(beneficiary);
}
}
```
```js theme={"theme":{"light":"github-light","dark":"github-dark"}}
import { NearBindgen, near, call, NearPromise } from 'near-sdk-js'
import { AccountId } from 'near-sdk-js/lib/types'
const MIN_STORAGE: bigint = BigInt("1000000000000000000000") // 0.001Ⓝ
@NearBindgen({})
class Contract {
@call({})
create_delete({prefix, beneficiary}:{prefix: String, beneficiary: AccountId}) {
const account_id = `${prefix}.${near.currentAccountId()}`
NearPromise.new(account_id)
.createAccount()
.transfer(MIN_STORAGE)
.deleteAccount(beneficiary)
}
@call({})
self_delete({beneficiary}:{beneficiary: AccountId}) {
NearPromise.new(near.currentAccountId())
.deleteAccount(beneficiary)
}
}
```
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
from near_sdk_py import call, Contract
from near_sdk_py.promises import Promise
from near_sdk_py.constants import ONE_NEAR
# Minimum amount needed for storage
MIN_STORAGE = ONE_NEAR // 1000 # 0.001Ⓝ
class ExampleContract(Contract):
@call
def create_delete(self, prefix, beneficiary):
"""Create an account and immediately delete it, sending funds to a beneficiary"""
# Generate the new account ID
account_id = f"{prefix}.{self.current_account_id}"
# Create the account, transfer funds, then delete it
return Promise.create_batch(account_id)\
.create_account()\
.transfer(MIN_STORAGE)\
.delete_account(beneficiary)
@call
def self_delete(self, beneficiary):
"""Delete this contract's account"""
# Delete the account and send remaining funds to beneficiary
return Promise.create_batch(self.current_account_id)\
.delete_account(beneficiary)
```
**Token Loss**
If the beneficiary account does not exist the funds will be [**dispersed among validators**](../../protocol/network/token-loss).
**Token Loss**
Do **not** use `delete` to try fund a new account. Since the account doesn't exist the tokens will be lost.